KubeBlocks 面试题库

ClusterDefinition (拓扑模板)
    └── ComponentDefinition (组件定义)
            └── ComponentVersion (版本与镜像)
                    └── Cluster (用户实例)

# 示例：Cluster 用户声明
apiVersion: apps.kubeblocks.io/v1alpha1
kind: Cluster
metadata:
  name: my-mysql
spec:
  clusterDefinitionRef: apecloud-mysql      # 引用 ClusterDefinition
  componentSpecs:
    - name: mysql
      componentDefRef: mysql                # 引用 ComponentDefinition
      replicas: 3
      resources:
        requests:
          cpu: "4"
          memory: 8Gi
      volumeClaimTemplates:
        - name: data
          spec:
            accessModes: [ReadWriteOnce]
            resources:
              requests:
                storage: 100Gi

postgresql-addon/
├── Chart.yaml
├── values.yaml
├── templates/
│   ├── clusterdefinition.yaml     # 数据库拓扑定义
│   ├── componentdefinition.yaml   # 组件工作负载与生命周期
│   ├── componentversion.yaml      # 版本与镜像映射
│   ├── scripts.yaml               # 配置模板（ConfigMap）
│   └── grafana-dashboard.yaml     # 监控仪表板

kbcli addon list                     # 列出已安装 Addon
kbcli addon search mysql             # 搜索可用 Addon
kbcli addon install apecloud-mysql   # 安装 MySQL Addon
kbcli addon enable apecloud-mysql    # 启用 Addon
kbcli addon disable apecloud-mysql   # 禁用 Addon
kbcli addon uninstall apecloud-mysql # 卸载 Addon

probes:
  roleProbe:
    failureThreshold: 3
    periodSeconds: 2
    commands:
      polling:
        - mysql
        - -uroot
        - -e
        - "SELECT role FROM apecloud_mysql.consensus_info"

RSM Controller
    ├── 管理 N 个 InstanceSet（分组管理 Pod）
    ├── 通过 Role Probe 检测每个 Pod 的角色
    ├── 根据角色调整 Pod 的就绪状态和 Service 路由
    └── Pod 更新时按角色顺序执行（先 Secondary，后 Primary）

User → OpsRequest (Create)
  → OpsRequest Controller (Validate + Admission)
    → 将 OpsRequest 转化为针对 Pod/Component 的具体操作
      → 调用 RSM Controller 执行分批更新
        → Lorry Sidecar 在每个 Pod 上执行 Pre/Post Hook（如停写、切换 VIP）
          → 更新 OpsRequest.Status 反映阶段进展

Configuration CR
    ├── ConfigConstraint（参数约束）
    │     ├── StaticParameters（仅重启生效）
    │     ├── DynamicParameters（可动态生效）
    │     └── ImmutableParameters（不可变更）
    ├── ConfigSpec（引用 ConfigMap 模板）
    └── Cluster（关联集群）

# 步骤 1：创建 reconfiguring OpsRequest
apiVersion: apps.kubeblocks.io/v1alpha1
kind: OpsRequest
metadata:
  name: my-mysql-config-change
spec:
  clusterRef: my-mysql
  type: Reconfiguring
  reconfiguring:
    - componentName: mysql
      configFile: my.cnf
      parameters:
        - key: max_connections
          value: "500"
        - key: innodb_buffer_pool_size
          value: "2G"

OpsRequest → ConfigConstraint 校验 → 分类参数（Static/Dynamic）
  → Static: 更新 ConfigMap, 滚动重启 Pod
  → Dynamic: Lorry 调用引擎的运行时 API 应用参数
    → 同时更新 ConfigMap 保持声明与运行时一致

# 创建备份策略
kbcli cluster edit-backup-policy my-pg \
  --backup-repo s3-repo \
  --cron "0 2 * * *" \
  --retention 7

# 按需创建备份
kbcli cluster backup my-pg --backup-type full

# 从备份恢复到新集群
kbcli cluster restore my-pg-restored \
  --backup-name my-pg-backup-20250101 \
  --restore-to-time "2025-01-01T10:30:00Z"  # PITR

Pending → Creating → Running → Succeed / Failed
                   ↓
                Cancelling → Cancelled

apiVersion: apps.kubeblocks.io/v1alpha1
kind: OpsRequest
metadata:
  name: scale-out-mysql
spec:
  clusterRef: my-mysql
  type: HorizontalScaling
  horizontalScaling:
    - componentName: mysql
      replicas: 5

kbcli cluster vscale my-pg --components pg=memory=8Gi,cpu=4

apiVersion: apps.kubeblocks.io/v1alpha1
kind: ClusterDefinition
metadata:
  name: apecloud-mysql-cluster
spec:
  componentDefs:
    - name: mysql-compdef          # 计算 + 存储组件
      componentDefRef: apecloud-mysql
    - name: proxy-compdef          # 代理组件（读写分离）
      componentDefRef: apecloud-mysql-proxy
  topology:                         # 拓扑编排策略
    - name: standalone
      components:
        - name: mysql
          compDef: mysql-compdef
    - name: replication
      components:
        - name: mysql
          compDef: mysql-compdef
        - name: proxy
          compDef: proxy-compdef
    - name: sharding
      shardingSpec:                # 分片编排
        shardingDefRef: mysql-sharding

kbcli cluster create my-sharded-mysql \
  --cluster-definition apecloud-mysql \
  --topology sharding \
  --shards 4 \
  --set mysql.replicas=3 \
  --set proxy.replicas=2

          Client
            |
      [ProxySQL/VTTablet]          ← 读写分离 (R + W)
       /    |    \
  [Primary] [Secondary] [Secondary] ← RSM 管理，Raft Consensus 选主
      |
  [Lorry Sidecar]                   ← 角色检测, 配置热更新, 备份代理

kbcli cluster create my-mysql \
  --cluster-definition apecloud-mysql \
  --topology replication \
  --set mysql.replicas=3 \
  --set mysql.resources.cpu=4 \
  --set mysql.resources.memory=8Gi \
  --set mysql.storage=100Gi

          Client
            |
      [PgBouncer]                ← 连接池，读写分离
       /         \
  [Primary]   [Standby-1] [Standby-2]
      |            |           |
  [Patroni]    [Patroni]   [Patroni]   ← 高可用管理
      |            |           |
         Etcd Cluster (3 节点)          ← DCS 分布式一致性存储

kbcli cluster create my-pg \
  --cluster-definition apecloud-postgresql \
  --topology replication \
  --set postgresql.replicas=3 \
  --set postgresql.resources.cpu=4 \
  --set postgresql.resources.memory=8Gi \
  --set postgresql.storage=200Gi

                  Client
                    |
            [Redis Proxy / Smart Client]
                    |
    +---------+---------+---------+
    |         |         |         |
[M1]  [M2]  [M3]     [M4]     [M5]    ← 5 个 Master，各负责部分 Slot
[S1]  [S2]  [S3]     [S4]     [S5]    ← 每个 Master 配一个 Slave

# Sentinel 模式
kbcli cluster create my-redis-sentinel \
  --cluster-definition redis \
  --topology sentinel \
  --set redis.replicas=3 \
  --set sentinel.replicas=3

# Redis Cluster 模式
kbcli cluster create my-redis-cluster \
  --cluster-definition redis \
  --topology cluster \
  --shards 3 \
  --set redis.replicas=2

                 Application
                      |
               [mongos-1] [mongos-2]        ← 查询路由层
                /         \
      [Config Server Replicaset]             ← 元数据存储（3 节点）
                |
    +--------+--------+--------+
    |        |        |        |
[Shard-1] [Shard-2] [Shard-3] [Shard-4]     ← 数据分片层
(3 nodes) (3 nodes) (3 nodes) (3 nodes)

kbcli cluster create my-mongo \
  --cluster-definition mongodb \
  --topology replicaset \
  --set mongodb.replicas=3 \
  --set mongodb.resources.cpu=2 \
  --set mongodb.resources.memory=4Gi \
  --set mongodb.storage=100Gi

               Producer / Consumer
                      |
         +--------+--------+--------+
         |        |        |        |
     [Broker-1][Broker-2][Broker-3]  ← 数据面，处理消息读写
         |        |        |
         +--------+--------+
                  |
     [Controller-1][Controller-2][Controller-3]  ← 控制面，管理元数据

# Combined 模式
kbcli cluster create my-kafka \
  --cluster-definition kafka \
  --topology combined \
  --set kafka.replicas=3 \
  --set kafka.storage=200Gi

# Separated 模式
kbcli cluster create my-kafka \
  --cluster-definition kafka \
  --topology separated \
  --set kafka.replicas=3 \
  --set controller.replicas=3 \
  --set kafka.storage=300Gi

# ReadWrite Service（仅路由到 Primary）
apiVersion: v1
kind: Service
metadata:
  name: my-mysql-rw
spec:
  selector:
    app.kubernetes.io/instance: my-mysql
    kubeblocks.io/role: primary       # 仅匹配 Primary

# Readonly Service（路由到 Secondary）
apiVersion: v1
kind: Service
metadata:
  name: my-mysql-ro
spec:
  selector:
    app.kubernetes.io/instance: my-mysql
    kubeblocks.io/role: secondary     # 仅匹配 Secondary

1. Lorry Role Probe 检测到 Primary 不健康
   → 将 Primary Pod 标记为 Unknown / Failed
2. KubeBlocks Controller 触发故障切换
   → 如为 Raft 模式：等待 Raft 集群自动选出新 Leader
   → 如为 Patroni 模式：Patroni 通过 Etcd 协调切换
3. Controller 更新 Pod Label（role: primary → secondary, role: secondary → primary）
4. Service Selector 自动更新，流量切至新 Primary
5. MemberLeave Action 在旧 Primary Pod 上执行清理
6. MemberJoin Action 在新 Primary Pod 上执行初始化

componentSpecs:
  - name: mysql
    volumeClaimTemplates:
      - name: data              # 数据目录
        spec:
          accessModes: [ReadWriteOnce]
          storageClassName: ssd-storageclass
          resources:
            requests:
              storage: 100Gi
      - name: log               # 日志目录（Binlog / WAL）
        spec:
          accessModes: [ReadWriteOnce]
          storageClassName: hdd-storageclass
          resources:
            requests:
              storage: 50Gi

kbcli cluster volume-expand my-mysql --components mysql=data=200Gi

apecloud-mysql:8.0.30-20240101
├── /opt/mysql/
│   ├── 8.0.29/      ← 旧版本二进制
│   └── 8.0.30/      ← 新版本二进制
├── /opt/mysql/current → symlink to active version
└── switch-version.sh    ← 版本切换脚本

apiVersion: apps.kubeblocks.io/v1alpha1
kind: OpsRequest
metadata:
  name: pg-upgrade
spec:
  clusterRef: my-pg
  type: Upgrade
  upgrade:
    clusterVersionRef: postgresql-15.4.0
    strategy: InPlace        # 或 RollingUpdate

graph TD
    subgraph Pod["Pod"]
        Lorry["Lorry<br/>(Sidecar)"]
        Main["MySQL/PG/etc<br/>(Main Container)"]
        SharedVol["Shared Volume<br/>/var/lib/kubeblocks/"]
    end

    Lorry <-->|"Unix Socket"| Main
    Lorry --> SharedVol
    Main --> SharedVol

# ComponentDefinition 中的 Lorry 定义
runtime:
  containers:
    - name: lorry
      image: apecloud/lorry:latest
      ports:
        - containerPort: 3501          # Lorry HTTP API
        - containerPort: 50001         # Probe API
      volumeMounts:
        - name: scripts
          mountPath: /kubeblocks/scripts   # 角色检测脚本
        - name: config                    # 挂载配置目录
          mountPath: /kubeblocks/conf

1. Lorry 每 periodSeconds 执行一次 Role Probe 脚本
2. 解析脚本输出，获取当前 Pod 角色
3. 将角色写入 Pod Labels: kubeblocks.io/role={leader,follower,learner}
4. 触发 Controller 同步 Service Selector
5. 角色变更时触发 MemberJoin/MemberLeave Action

# 读写
mysql -h my-mysql-mysql.default.svc.cluster.local -u root -p

# 只读
mysql -h my-mysql-mysql-ro.default.svc.cluster.local -u readonly -p

Database Pod (MySQL/PostgreSQL/Redis...)
    ├── Lorry Sidecar (Metrics Exporter 代理)
    │     └── 暴露 /metrics (Prometheus 格式)
    ├── Prometheus PodMonitor / ServiceMonitor
    │     └── 自动发现并抓取 /metrics
    ├── Prometheus Server
    │     └── 存储时间序列数据
    └── Grafana
          └── 导入 Addon 预置 Dashboard

# 查看集群的 Grafana Dashboard
kbcli cluster dashboard my-mysql

# 添加自定义监控仪表板
kbcli dashboard install --name custom-mysql --file ./custom-dashboard.json

                  KubeBlocks API
                       |
          +------------+------------+
          |            |            |
       [AWS EKS]   [GCP GKE]   [Azure AKS]   [Aliyun ACK]
          |            |            |            |
     gp3 / io2    pd-ssd       Managed      ESSD PL2
     StorageClass  StorageClass  Disk        StorageClass
          |            |            |            |
        S3           GCS          Azure        OSS/ MinIO
     (Backup)      (Backup)    Blob(Backup)   (Backup)

# 添加多云集群上下文
kbcli context add aws-prod --kubeconfig ~/.kube/aws-config
kbcli context add gcp-prod --kubeconfig ~/.kube/gcp-config

# 切换并操作不同云环境
kbcli context use aws-prod
kbcli cluster list              # 列出 AWS 上的数据库集群

kbcli context use gcp-prod
kbcli cluster list              # 列出 GCP 上的数据库集群

graph TD
    S1["1. Role Probe 检测到 Primary Pod 不可达（连续 3 次）"]
    S2["2. Lorry 将 Pod 标记为 Unknown"]
    S3["3. 引擎自动选主<br/>Raft: Raft 集群自动发起 Leader Election<br/>Patroni: 通过 Etcd 发起选主"]
    S4["4. 新 Primary 的 Label 更新"]
    S5["5. MemberLeave Action 在旧 Pod 执行清理"]
    S6["6. Service Selector 自动更新，流量切至新 Primary"]

    S1 --> S2 --> S3 --> S4 --> S5 --> S6

Database Management on K8s
├── 通用框架：KubeBlocks (Operator Framework)
├── 专用 Operator
│   ├── PostgreSQL：CloudNativePG / Zalando / Crunchy Data
│   ├── MySQL：Vitess Operator / MySQL Operator (Oracle) / Percona Operator
│   ├── MongoDB：MongoDB Community Operator / Percona Operator for MongoDB
│   └── Redis：Redis Operator (OT-CONTAINER-KIT)
└── 平台集成
    └── KubeDB (AppsCode)

curl -fsSL https://kubeblocks.io/installer/install_cli.sh | bash

# 创建集群
kbcli cluster create my-mysql \
  --cluster-definition apecloud-mysql \
  --topology replication \
  --set mysql.replicas=3 \
  --set mysql.storage=100Gi

# 列出集群
kbcli cluster list

# 查看集群详情
kbcli cluster describe my-mysql

# 查看集群组件
kbcli cluster list-components my-mysql

# 查看集群实例（Pod 级别）
kbcli cluster list-instances my-mysql

# 查看集群事件
kbcli cluster list-events my-mysql

# 删除集群
kbcli cluster delete my-mysql

# 垂直扩容
kbcli cluster vscale my-pg --components pg=memory=8Gi,cpu=4

# 水平扩容
kbcli cluster hscale my-mysql --components mysql=5

# 存储扩容
kbcli cluster volume-expand my-mysql --components mysql=data=200Gi

# 重启
kbcli cluster restart my-mysql

# 停止 / 启动
kbcli cluster stop my-mysql
kbcli cluster start my-mysql

# 版本升级
kbcli cluster upgrade my-pg \
  --cluster-version postgresql-15.4.0

# 配置变更
kbcli cluster configure my-mysql \
  --component mysql \
  --config-file my.cnf \
  --set max_connections=500

# 查看备份策略
kbcli cluster list-backup-policy my-mysql

# 编辑备份策略
kbcli cluster edit-backup-policy my-mysql \
  --cron "0 2 * * *" \
  --retention 7

# 创建备份
kbcli cluster backup my-mysql --type full

# 查看备份
kbcli cluster list-backups my-mysql

# 恢复
kbcli cluster restore my-restored \
  --backup-name my-mysql-backup-20250101

kbcli addon list                         # 列出已安装 Addon
kbcli addon search mysql                 # 搜索可用 Addon
kbcli addon install apecloud-mysql       # 安装
kbcli addon enable apecloud-mysql        # 启用
kbcli addon disable apecloud-mysql       # 禁用
kbcli addon uninstall apecloud-mysql     # 卸载

# 使用 Kind 在本地快速启动 KubeBlocks + MySQL
kbcli playground init

# 获取连接信息
kbcli cluster connect my-mysql --show-password

# 端口转发到本地
kbcli cluster connect my-mysql --port-forward

# 打开 Grafana Dashboard
kbcli cluster dashboard my-mysql

kbcli cluster logs my-mysql                    # 查看集群日志
kbcli cluster describe-ops <ops-name>          # 查看运维操作详情
kbcli cluster list-ops my-mysql                # 列出集群运维操作历史