RadonDB MySQL 面试题

graph TD
    Operator["RadonDB Operator<br/>(CRD Watch / Reconcile Loop)"]
    HeadlessSvc["Headless Service<br/>(mysql-radondb-headless)"]

    subgraph StatefulSet["StatefulSet Replicas (3)"]
        Pod0["Pod-0: MySQL / Xenon / Exp<br/>Leader"]
        Pod1["Pod-1: MySQL / Xenon / Exp<br/>Follower"]
        Pod2["Pod-2: MySQL / Xenon / Exp<br/>Follower"]
    end

    Operator -->|"Watch / Manage"| HeadlessSvc
    HeadlessSvc --> Pod0

Xenon 心跳与选举流程：

  Leader Xenon                Follower Xenon-1        Follower Xenon-2
      │                            │                        │
      │──── Heartbeat ────────────►│                        │
      │──── Heartbeat ────────────────────────────────────►│
      │                            │                        │
      │   (Leader 宕机 / 网络分区)                             │
      │                            │                        │
      │  (Tick 超时)              │  (Tick 超时)           │
      │                            │                        │
      │◄──── RequestVote ──────────│                        │
      │                            │── RequestVote ───────►│
      │                            │◄── VoteGranted ───────│
      │                            │                        │
      │                            │  New Leader Elected    │
      │                            │  SET GLOBAL read_only=OFF │
      │                            │◄── Replication ───────│

# Xenon 选举相关配置参数
{
  "raft-timeout": 3000,        # 心跳超时（毫秒）
  "raft-election-timeout": 6000, # 选举超时（毫秒）
  "raft-heartbeat-interval": 150, # 心跳间隔（毫秒）
  "leader-start-command": "mysql -e 'SET GLOBAL read_only=OFF;'",
  "leader-stop-command": "mysql -e 'SET GLOBAL read_only=ON;'"
}

apiVersion: mysql.radondb.com/v1beta1
kind: MysqlCluster
metadata:
  name: my-cluster
spec:
  mysqlVersion: "8.0.30"                    # MySQL 版本
  replicas: 3                                # 副本数（奇数，至少 1）
  image: radondb/mysql:8.0.30                # MySQL 镜像
  xenonImage: radondb/xenon:1.1.7            # Xenon 镜像
  backupImage: radondb/percona-xtrabackup:2.4 # 备份镜像
  
  mysqlOpts:                                # MySQL 配置参数
    innodb_buffer_pool_size: "2G"
    max_connections: 1000
    slow_query_log: "ON"
    character-set-server: "utf8mb4"
    
  xenonOpts:                                # Xenon 配置参数
    raft-timeout: 3000
    raft-election-timeout: 6000
    
  resources:                                # 资源配额
    requests:
      cpu: "2"
      memory: "4Gi"
    limits:
      cpu: "4"
      memory: "8Gi"
      
  persistence:                              # 持久化存储
    size: "100Gi"
    storageClassName: "local-storage"
    
  backup:                                   # 备份策略
    schedule: "0 2 * * *"                  # Cron 表达式，每天凌晨 2 点
    keepNum: 7                              # 保留最近 7 个备份
    type: "full"                            # full / incremental
    
  monitoring:                               # 监控配置
    exporterImage: radondb/mysqld-exporter:0.14.0
    serviceMonitorLabels:
      team: dba
    
  service:                                  # 服务暴露方式
    type: ClusterIP                         # ClusterIP / NodePort / LoadBalancer
    nodePort: 30306

status:
  conditions:
  - type: Ready
    status: "True"
    lastTransitionTime: "2025-03-15T10:00:00Z"
  leader: my-cluster-0                       # 当前主节点
  replicas: 3                                # 实际副本数
  readyReplicas: 3                           # Ready 状态副本数

# Headless Service - 为每个 Pod 提供稳定 DNS
apiVersion: v1
kind: Service
metadata:
  name: my-cluster-headless
spec:
  clusterIP: None
  selector:
    app: mysql
    cluster: my-cluster
  ports:
  - name: mysql
    port: 3306

# 读写 Service - 由 Operator 动态将 Label 指向 Leader
apiVersion: v1
kind: Service
metadata:
  name: my-cluster
spec:
  type: ClusterIP
  selector:
    app: mysql
    cluster: my-cluster
    role: leader          # Operator 动态管理此 Label
  ports:
  - name: mysql
    port: 3306

affinity:
  podAntiAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
    - labelSelector:
        matchLabels:
          app: mysql
          cluster: my-cluster
      topologyKey: kubernetes.io/hostname

# 全量备份 CronJob 示例
apiVersion: mysql.radondb.com/v1beta1
kind: MysqlBackup
metadata:
  name: my-cluster-backup-20250315
spec:
  clusterName: my-cluster
  type: full                        # full / incremental
  storage:
    type: s3
    s3:
      bucket: radondb-backups
      endpoint: s3.example.com
      region: us-east-1
      secretName: s3-credentials

Application
    ├── Write ──► Service(role:leader) ──► Leader Pod (read_only=OFF)
    │
    └── Read  ──► Service(role:follower) ──► Follower Pod-1 (read_only=ON)
                                          ──► Follower Pod-2 (read_only=ON)

# 只读 Service 示例
apiVersion: v1
kind: Service
metadata:
  name: my-cluster-readonly
spec:
  type: ClusterIP
  selector:
    app: mysql
    cluster: my-cluster
    role: follower
  ports:
  - name: mysql
    port: 3306

graph TD
    Prometheus["Prometheus"]
    ServiceMonitor["ServiceMonitor CRD"]
    Grafana["Grafana"]
    Exporter["mysqld-exporter<br/>(Sidecar)<br/>:9104"]
    MySQL["MySQL"]

    Prometheus --> ServiceMonitor --> Grafana
    Prometheus -->|"Scrape /metrics"| Exporter
    ServiceMonitor --> Exporter
    Exporter -->|"Localhost:3306"| MySQL

# ServiceMonitor CRD 示例
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: my-cluster-mysql
  labels:
    release: prometheus
spec:
  selector:
    matchLabels:
      app: mysql
      cluster: my-cluster
  endpoints:
  - port: metrics
    interval: 30s
    path: /metrics

# PDB 示例
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: my-cluster-pdb
spec:
  minAvailable: 2
  selector:
    matchLabels:
      app: mysql
      cluster: my-cluster

kubectl patch mysqlcluster my-cluster --type='merge' \
  -p '{"spec":{"image":"radondb/mysql:8.0.35"}}'

# MySQLCluster 持久化配置
spec:
  persistence:
    size: "200Gi"
    storageClassName: "local-ssd"
    accessModes:
    - ReadWriteOnce
    resources:
      requests:
        storage: 200Gi

总需求 = (数据大小 + 索引大小) × 1.5(碎片/膨胀) + binlog 保留大小 + 临时表空间 + 快照/克隆预留

graph LR
    F1["全量<br/>Day 1(周日)"] --> I1["增量(1)<br/>Day 2"]
    I1 --> I2["增量(2)<br/>Day 3"]
    I2 --> I3["增量(3)<br/>Day 4"]
    I3 --> F2["全量<br/>Day 5(周四)"]
    F2 --> I4["增量(1)<br/>Day 6"]
    I4 --> I5["增量(2)<br/>Day 7"]
    I5 --> F3["全量<br/>Day 8(周日)"]

T+0s      Leader 故障（OOM/NodeFailure/XenonCrash）
T+0~3s    Follower 心跳超时（raft-timeout: 3000ms）
T+3s      Follower 转为 Candidate，发送 RequestVote
T+3~4s    获得多数票，新 Leader 选出
T+4s      新 Leader 执行 leader-start-command（read_only=OFF）
T+4~5s    新 Leader 广播心跳，Follower 感知新 Leader 身份
T+5~8s    Follower CHANGE MASTER TO 新 Leader
T+5~10s   Operator 更新 Service Label（role: leader 指向新 Pod）
T+10~30s  应用感知连接中断 → 重连 → 恢复写入

# 手动触发 Leader 切换
kubectl exec -it my-cluster-0 -c xenon -- xenoncli raft transfer

# 查看集群当前状态
kubectl exec -it my-cluster-0 -c xenon -- xenoncli cluster raft
kubectl exec -it my-cluster-0 -c xenon -- xenoncli mysql status

# MySQLCluster 日志相关配置
spec:
  mysqlOpts:
    # Error Log
    log_error_verbosity: "2"        # 1:errors 2:errors+warnings 3:errors+warnings+notes
    
    # Slow Query
    slow_query_log: "ON"
    long_query_time: "1.0"         # 超过 1 秒计入慢查询
    log_queries_not_using_indexes: "ON"
    log_slow_admin_statements: "ON"
    min_examined_row_limit: "1000" # 扫描行数超过 1000 才记录
    
    # Binlog
    log_bin: "ON"
    binlog_format: "ROW"           # ROW 格式利于复制一致性
    binlog_row_image: "FULL"
    sync_binlog: "1"               # 每次事务同步 binlog 到磁盘
    expire_logs_days: "7"          # binlog 保留 7 天
    max_binlog_size: "500M"
    binlog_cache_size: "32768"

MySQL Container stdout/stderr
     │
     ├──► kubectl logs (临时查看)
     │
     └──► Fluent Bit / Filebeat DaemonSet
              │
              ├──► Elasticsearch / Loki
              │
              └──► Grafana (日志查询)

spec:
  mysqlOpts:
    log_output: "FILE"                    # 输出到文件而非 stderr
    slow_query_log_file: "/var/lib/mysql/slow-query.log"
    general_log_file: "/var/lib/mysql/general.log"

apiVersion: mysql.radondb.com/v1beta1
kind: MysqlVersion
metadata:
  name: mysql-8.0.30
spec:
  version: "8.0.30"
  mysqlImage: "radondb/mysql:8.0.30"
  xenonImage: "radondb/xenon:1.1.7"
  mysqlExporterImage: "radondb/mysqld-exporter:0.14.0"
  backupImage: "radondb/percona-xtrabackup:8.0.30"
  initImage: "radondb/mysql:8.0.30"
  # 升级限制：仅允许从指定版本平滑升级
  upgradeConstraints:
    - from: "8.0.28"
    - from: "8.0.29"
    - from: "8.0.30"

# 查看支持的 MySQL 版本
kubectl get mysqlversion

# 修改集群使用的 MySQL 版本
kubectl patch mysqlcluster my-cluster --type='merge' \
  -p '{"spec":{"mysqlVersion":"8.0.35"}}'

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-cluster-config
data:
  my.cnf: |
    [mysqld]
    server-id=100
    innodb_buffer_pool_size=2G
    max_connections=1000
    character-set-server=utf8mb4
    collation-server=utf8mb4_unicode_ci
    slow_query_log=ON
    long_query_time=1.0
    binlog_format=ROW
    sync_binlog=1
    gtid_mode=ON
    enforce-gtid-consistency=ON    

  xenon.json: |
    {
      "raft-timeout": 3000,
      "raft-election-timeout": 6000,
      "admit-defeat-hearbeat-count": 5,
      "leader-start-command": "mysql -e 'SET GLOBAL read_only=OFF; SET GLOBAL super_read_only=OFF;'",
      "leader-stop-command": "mysql -e 'SET GLOBAL super_read_only=ON; SET GLOBAL read_only=ON;'"
    }    

# 1. 修改 ConfigMap 后重新应用
kubectl apply -f configmap.yaml

# 2. 执行滚动重启，使静态参数生效
kubectl rollout restart statefulset my-cluster

# 3. 仅修改动态参数（无需重启）
kubectl exec -it my-cluster-0 -- mysql -e "SET GLOBAL max_connections=2000;"

graph TD
    subgraph Leader["Leader (my-cluster-0)"]
        Data["db1 / db2 / db3 (全量数据)<br/>所有写入在此完成"]
    end

    Leader -->|"Binlog Replication"| Follower1["Follower<br/>(只读副本)<br/>全量数据"]
    Leader -->|"Binlog Replication"| Follower2["Follower<br/>(只读副本)<br/>全量数据"]

# ClusterIP（默认）
spec:
  service:
    type: ClusterIP

# NodePort
spec:
  service:
    type: NodePort
    nodePort: 30306

# LoadBalancer
spec:
  service:
    type: LoadBalancer
    loadBalancerIP: "10.0.0.100"
    annotations:
      service.beta.kubernetes.io/aws-load-balancer-internal: "true"
      service.beta.kubernetes.io/aws-load-balancer-type: "nlb"

apiVersion: v1
kind: Service
metadata:
  name: my-cluster-readonly
  labels:
    app: mysql
    cluster: my-cluster
spec:
  type: ClusterIP
  selector:
    app: mysql
    cluster: my-cluster
    role: follower
  ports:
  - name: mysql
    port: 3306
    targetPort: 3306

spec:
  tls:
    enabled: true
    # 引用包含 TLS 证书的 Secret
    secretName: mysql-tls-secret
    # 可选：指定 SAN（Subject Alternative Name）
    issuerRef:
      name: mysql-ca-issuer
      kind: Issuer

[mysqld]
ssl_ca=/etc/mysql/certs/ca.crt
ssl_cert=/etc/mysql/certs/tls.crt
ssl_key=/etc/mysql/certs/tls.key
require_secure_transport=ON

# NetworkPolicy 限制数据库访问来源
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: mysql-network-policy
spec:
  podSelector:
    matchLabels:
      app: mysql
      cluster: my-cluster
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: backend
    - podSelector:
        matchLabels:
          app: my-app
    ports:
    - protocol: TCP
      port: 3306

-- 应用用户仅授权必要库表
CREATE USER 'app_user'@'%' IDENTIFIED BY 'secure_password' REQUIRE SSL;
GRANT SELECT, INSERT, UPDATE, DELETE ON mydb.* TO 'app_user'@'%';

-- 监控用户仅授予查询权限
CREATE USER 'monitor'@'%' IDENTIFIED BY 'monitor_password' REQUIRE SSL;
GRANT PROCESS, REPLICATION CLIENT, SELECT ON *.* TO 'monitor'@'%';

apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: mysql-alerts
  labels:
    release: prometheus
spec:
  groups:
  - name: mysql-critical
    rules:
    # P0: MySQL 实例宕机
    - alert: MySQLDown
      expr: mysql_up == 0
      for: 1m
      labels:
        severity: critical
      annotations:
        summary: "MySQL instance XQOPEN $labels.pod XQCLOSE is down"
        description: "MySQL on pod XQOPEN $labels.pod XQCLOSE has been down for more than 1 minute."
        runbook_url: "https://wiki.example.com/mysql-down"

    # P0: 复制中断
    - alert: MySQLReplicationBroken
      expr: mysql_slave_status_slave_io_running == 0 or mysql_slave_status_slave_sql_running == 0
      for: 1m
      labels:
        severity: critical
      annotations:
        summary: "MySQL replication broken on XQOPEN $labels.pod XQCLOSE"

  - name: mysql-warning
    rules:
    # P1: 复制延迟
    - alert: MySQLReplicationLag
      expr: mysql_slave_status_seconds_behind_master > 30
      for: 5m
      labels:
        severity: warning
      annotations:
        summary: "MySQL replication lag XQOPEN $value XQCLOSEs on XQOPEN $labels.pod XQCLOSE"

    # P1: 连接数超过 80%
    - alert: MySQLHighConnectionUsage
      expr: (mysql_global_status_threads_connected / mysql_global_variables_max_connections) * 100 > 80
      for: 5m
      labels:
        severity: warning
      annotations:
        summary: "MySQL connection usage XQOPEN $value | humanize XQCLOSE% on XQOPEN $labels.pod XQCLOSE"

    # P1: 缓冲池命中率低于 95%
    - alert: MySQLLowBufferPoolHitRate
      expr: (rate(mysql_global_status_innodb_buffer_pool_read_requests[10m]) - rate(mysql_global_status_innodb_buffer_pool_reads[10m])) / rate(mysql_global_status_innodb_buffer_pool_read_requests[10m]) < 0.95
      for: 10m
      labels:
        severity: warning
      annotations:
        summary: "InnoDB buffer pool hit rate below 95% on XQOPEN $labels.pod XQCLOSE"

    # P1: 磁盘增长预测
    - alert: MySQLDiskSpacePrediction
      expr: predict_linear(mysql_global_variables_datadir_size_bytes[6h], 24*3600) > 200*1024*1024*1024
      for: 1h
      labels:
        severity: warning
      annotations:
        summary: "MySQL data directory predicted to exceed 200GB in 24h"

  - name: mysql-info
    rules:
    # P2: 慢查询增长
    - alert: MySQLSlowQueriesIncrease
      expr: rate(mysql_global_status_slow_queries[5m]) > 10
      for: 10m
      labels:
        severity: info
      annotations:
        summary: "Slow queries rate XQOPEN $value XQCLOSE/s on XQOPEN $labels.pod XQCLOSE"

    # P2: 磁盘使用超过 70%
    - alert: MySQLDiskSpaceUsage
      expr: (mysql_global_variables_datadir_size_bytes / 200*1024*1024*1024) * 100 > 70
      for: 1h
      labels:
        severity: info
      annotations:
        summary: "MySQL data directory usage XQOPEN $value | humanize XQCLOSE%"

// Xenon 脑裂防护配置
{
  "raft-timeout": 3000,
  "raft-election-timeout": 6000,
  "leader-start-command": "mysql -e 'SET GLOBAL read_only=OFF; SET GLOBAL super_read_only=OFF;'",
  "leader-stop-command": "mysql -e 'SET GLOBAL read_only=ON; SET GLOBAL super_read_only=ON;'",
  "admit-defeat-hearbeat-count": 5
}

graph TD
    subgraph AZ1["AZ-1 (us-east-1a)"]
        subgraph NodeA["Node-A"]
            Pod0["my-cluster-0<br/>MySQL<br/>Xenon<br/>PVC (SSD)"]
        end
    end
    subgraph AZ2["AZ-2 (us-east-1b)"]
        subgraph NodeB["Node-B"]
            Pod1["my-cluster-1<br/>MySQL<br/>Xenon<br/>PVC (SSD)"]
        end
    end
    subgraph AZ3["AZ-3 (us-east-1c)"]
        subgraph NodeC["Node-C"]
            Pod2["my-cluster-2<br/>MySQL<br/>Xenon<br/>PVC (SSD)"]
        end
    end

    Pod0 <-->|"Raft Heartbeat (跨 AZ)"| Pod1
    Pod1 <-->|"Raft Heartbeat (跨 AZ)"| Pod2
    Pod0 <-->|"Raft Heartbeat (跨 AZ)"| Pod2

spec:
  replicas: 3
  affinity:
    podAntiAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        podAffinityTerm:
          labelSelector:
            matchLabels:
              app: mysql
              cluster: my-cluster
          topologyKey: topology.kubernetes.io/zone  # 跨 AZ 分布

// 跨 AZ 部署 Xenon 建议配置
{
  "raft-timeout": 5000,
  "raft-election-timeout": 10000,
  "raft-heartbeat-interval": 250
}

[mysqld]
# InnoDB 核心
innodb_buffer_pool_size = 16G
innodb_buffer_pool_instances = 8
innodb_log_file_size = 2G
innodb_log_buffer_size = 256M
innodb_flush_log_at_trx_commit = 1
innodb_flush_method = O_DIRECT
innodb_io_capacity = 4000
innodb_io_capacity_max = 8000
innodb_read_io_threads = 8
innodb_write_io_threads = 8
innodb_page_cleaners = 8

# 连接
max_connections = 1000
thread_cache_size = 200
table_open_cache = 4000

# Binlog
binlog_format = ROW
sync_binlog = 1
binlog_cache_size = 1M

# 复制
slave_parallel_workers = 8
slave_parallel_type = LOGICAL_CLOCK

排查步骤：
1. kubectl describe pod my-cluster-0 → 查看 Events
2. kubectl logs my-cluster-0 -c init → Init Container 日志
3. kubectl logs my-cluster-0 -c mysql → MySQL 启动日志
4. kubectl logs my-cluster-0 -c xenon → Xenon 启动日志

常见原因：
- Init Container 数据目录校验失败 → PVC 损坏或目录为空
- MySQL 挂载卷权限问题 → fsGroup / runAsUser 未正确设置
- Xenon 无法连接 MySQL → /var/run/mysqld/mysqld.sock 不存在
- 磁盘空间不足 → PV 配额耗尽

-- 第 1 步：检查从库复制状态
SHOW SLAVE STATUS\G

-- 关键字段：
-- Slave_IO_Running / Slave_SQL_Running: 应为 Yes
-- Seconds_Behind_Master: 延迟秒数
-- Last_IO_Error / Last_SQL_Error: 错误信息

-- 常见错误及修复：
-- Error 1236 (binlog 被清理 / GTID 不一致)
STOP SLAVE;
RESET SLAVE;
CHANGE MASTER TO ...;
START SLAVE;

-- Error 1062 (主键冲突 / 重复数据)
STOP SLAVE;
SET GLOBAL SQL_SLAVE_SKIP_COUNTER=1;
START SLAVE;

-- Error 1032 (记录不存在 / DELETE/UPDATE 时找不到行)
STOP SLAVE;
SET GLOBAL SQL_SLAVE_SKIP_COUNTER=1;
START SLAVE;

# 查看 Raft 状态
kubectl exec -it my-cluster-0 -c xenon -- xenoncli cluster raft

# 手动重建 Raft 集群
kubectl exec -it my-cluster-0 -c xenon -- xenoncli cluster add --address my-cluster-1:8801
kubectl exec -it my-cluster-0 -c xenon -- xenoncli cluster add --address my-cluster-2:8801

# Xenon 日志排查
kubectl logs my-cluster-0 -c xenon | grep -E "raft|leader|election|timeout"

# 查看 Backup Job 状态
kubectl get mysqlbackup
kubectl describe mysqlbackup my-cluster-backup-xxx

# 查看 Job Pod 日志
kubectl logs job/my-cluster-backup-xxx

# 常见原因：
# - S3/MinIO 认证失败 → Secret 中的 AK/SK 错误
# - 磁盘空间不足 → 备份路径空间不足
# - MySQL 连接失败 → Xenon 未处于正常状态
# - 备份进程超时 → 数据集过大，xtrabackup 超时

-- 查看当前活跃查询
SHOW FULL PROCESSLIST;

-- 查看 InnoDB 引擎状态（锁争用 / 事务状态）
SHOW ENGINE INNODB STATUS\G

-- 查看当前锁等待
SELECT * FROM information_schema.innodb_lock_waits;
SELECT * FROM performance_schema.metadata_locks WHERE OBJECT_SCHEMA = 'mydb';

-- 查看慢查询
SELECT * FROM mysql.slow_log ORDER BY start_time DESC LIMIT 20;

-- 查看表统计信息
SELECT TABLE_NAME, TABLE_ROWS, DATA_LENGTH, INDEX_LENGTH
FROM information_schema.TABLES
WHERE TABLE_SCHEMA = 'mydb';

# 查看 Operator 版本
radondb-mysql-operator version

# 查看集群列表
kubectl get mysqlcluster

# 查看集群详细状态
kubectl describe mysqlcluster my-cluster

# 创建集群
kubectl apply -f mysql-cluster.yaml

# 手动触发备份
kubectl apply -f - <<EOF
apiVersion: mysql.radondb.com/v1beta1
kind: MysqlBackup
metadata:
  name: my-cluster-manual-backup-$(date +%Y%m%d%H%M%S)
spec:
  clusterName: my-cluster
  type: full
EOF

# 从备份恢复
kubectl apply -f mysql-restore.yaml

# 查看备份列表
kubectl get mysqlbackup

# 删除集群（保留 PVC）
kubectl delete mysqlcluster my-cluster

# 进入 Xenon 容器
kubectl exec -it my-cluster-0 -c xenon -- /bin/bash

# 查看 Raft 集群状态
xenoncli cluster raft

# 查看 Raft 成员
xenoncli cluster members

# 查看当前节点 MySQL 状态（角色、复制、GTID）
xenoncli mysql status

# 查看当前节点为 Leader 还是 Follower
xenoncli mysql role

# 手动触发 Leader 转移
xenoncli raft transfer

# 查看 Xenon 日志级别
xenoncli log level

# 通过 kubectl 直接进入 MySQL
kubectl exec -it my-cluster-0 -- mysql -uroot -p"${MYSQL_ROOT_PASSWORD}"

# 查看主从复制状态
kubectl exec -it my-cluster-1 -- mysql -e "SHOW SLAVE STATUS\G"

# 查看当前 Leader
kubectl get pods -l app=mysql,cluster=my-cluster,role=leader

# 查看所有可用的只读副本
kubectl get pods -l app=mysql,cluster=my-cluster,role=follower

# 临时重启 Xenon（不影响 MySQL）
kubectl exec -it my-cluster-0 -c xenon -- kill -HUP 1

# 查看 Operator 日志
kubectl logs -f deployment/radondb-mysql-operator -n radondb-system

# 按关键字过滤
kubectl logs deployment/radondb-mysql-operator -n radondb-system | grep -i "reconcile\|error\|leader"

# 集群健康检查
kubectl get mysqlcluster                              # CRD 状态 Ready
kubectl get pods -l cluster=my-cluster                # 所有 Pod Running
kubectl exec -it my-cluster-0 -c xenon -- xenoncli cluster raft  # Raft 正常
kubectl exec -it my-cluster-1 -- mysql -e "SHOW SLAVE STATUS\G"   # 复制正常

# 备份检查
kubectl get mysqlbackup                               # 最近备份 Completed
# 验证备份文件存在于 S3/MinIO

# 资源检查
kubectl top pods                                      # CPU/Memory 未达上限
kubectl get pvc                                       # PV 空间充足