SealOS 面试题

31 道题

分类: Kubernetes
题目数: 31 道

已阅读 0 / 31 题

1 SealOS 的核心定位是什么？解决了什么问题？

答案：

SealOS 是一个以 Kubernetes 为内核的云操作系统，解决 Kubernetes 集群的全生命周期管理问题，包括部署、升级、应用分发和运维管理。

核心定位：

云操作系统：将 Kubernetes 抽象为类似 Linux 的操作系统体验
集群生命周期管理：初始化、扩容、升级、备份、恢复
应用商店：一键部署复杂应用（如 MySQL 集群、Redis 集群）
多云一致性：在公有云、私有云、裸金属上保持一致的 K8s 体验

解决的问题：

问题	传统方式	SealOS 方案
集群部署复杂	kubeadm 手动配置	sealos apply Clusterfile
证书管理	手动生成和续期	自动管理
集群升级	kubeadm upgrade 多步操作	sealos upgrade
应用部署	Helm Charts 逐个安装	应用商店一键部署
多节点管理	SSH 逐个配置	自动并行分发

命令对比：

# 传统方式（10+ 步骤）
kubeadm init --pod-network-cidr=10.244.0.0/16
kubectl apply -f calico.yaml

# SealOS
sealos run labring/kubernetes:v1.28.0 labring/calico:v3.26.0 \
  --masters 192.168.1.10 \
  --nodes 192.168.1.11,192.168.1.12

2 SealOS 的架构由哪些组件构成？

答案：

SealOS 的架构分为命令行工具和集群组件两部分。

命令行工具（sealos CLI）：

运行在管理节点上，通过 SSH 或 Cloud API 管理集群
负责集群初始化、节点管理、镜像和应用分发
内置集群状态检查和诊断功能

集群组件：

组件	类型	职责
sealos-exec	System Service	接收 CLI 指令并执行节点级操作
lvscare	DaemonSet	高可用负载均衡器，管理 API Server VIP
registry	Deployment	集群内镜像仓库，分发应用镜像
image-cri-shim	DaemonSet	镜像 CRI 兼容桥接，调整镜像拉取地址

Clusterfile（集群声明文件）：

# Clusterfile
apiVersion: sealos.io/v1beta1
kind: Cluster
metadata:
  name: mycluster
spec:
  hosts:
  - ips:
    - 192.168.1.10
    - 192.168.1.11
    - 192.168.1.12
    roles: [master]
  - ips:
    - 192.168.1.13
    - 192.168.1.14
    roles: [node]
  image: labring/kubernetes:v1.28.0
  ssh:
    user: root
    passwd: your-password  # 或使用私钥
    port: 22

3 SealOS 如何处理集群的高可用（HA）部署？

答案：

SealOS 通过内建的 lvscare 组件实现 API Server 的高可用负载均衡。

HA 架构：

graph TD
    subgraph Master["3 个 Master 节点"]
        M1["Master-1 (192.168.1.10) + kube-apiserver"]
        M2["Master-2 (192.168.1.11) + kube-apiserver"]
        M3["Master-3 (192.168.1.12) + kube-apiserver"]
    end
    LV["lvscare (VIP: 10.103.0.1:6443)"] -->|"LVS 负载均衡"| M1
    LV -->|"LVS 负载均衡"| M2
    LV -->|"LVS 负载均衡"| M3
    Node["Node 节点 kubelet"] -->|"连接 VIP"| LV

lvscare 工作机制：

在每个节点上运行 lvscare，维护 LVS 规则
将 VIP:6443 负载均衡到所有健康的 API Server
自动检测 API Server 健康状态，故障自动摘除
无需外部负载均衡器（如 HAProxy、Nginx）

部署 HA 集群：

sealos run labring/kubernetes:v1.28.0 \
  --masters 192.168.1.10,192.168.1.11,192.168.1.12 \
  --nodes 192.168.1.13,192.168.1.14

验证 HA：

# 停止一个 Master 的 API Server
systemctl stop kube-apiserver

# 集群仍正常
kubectl get nodes  # 仍然可用

# lvscare 自动摘除故障 API Server

4 SealOS 的镜像（Image）机制是什么？

答案：

SealOS 使用 OCI 兼容的容器镜像格式分发 Kubernetes 集群和应用。

Kubernetes 镜像：

# 查看可用镜像
sealos images

# Kubernetes 基础镜像
labring/kubernetes:v1.28.0       # K8s 核心组件
labring/calico:v3.26.0           # CNI
labring/helm:v3.13.0             # Helm
labring/ingress-nginx:v1.9.0     # Ingress

镜像内容：

graph TD
    Root["labring/kubernetes:v1.28.0"]
    Root --> Reg["registry/（内置镜像仓库内容）"]
    Reg --> APIS["kube-apiserver"]
    Reg --> CM["kube-controller-manager"]
    Reg --> Sched["kube-scheduler"]
    Reg --> Proxy["kube-proxy"]
    Reg --> Etcd["etcd"]
    Reg --> DNS["coredns"]
    Reg --> Pause["pause"]
    Root --> Img["images/（镜像元数据）"]
    Img --> Shim["shim"]
    Root --> KF["Kubefile（镜像构建文件，类比 Dockerfile）"]
    Root --> Mani["manifests/（初始化清单）"]
    Mani --> Init["init.yaml"]

构建自定义镜像：

# Kubefile
FROM labring/kubernetes:v1.28.0

# 添加 CNI 插件
COPY images/calico images/

# 添加用户定义的 DaemonSet
COPY manifests/ manifests/

# 添加应用
CMD ["kubectl apply -f manifests/"]

sealos build -t labring/mycluster:v1.0 -f Kubefile .

5 SealOS 如何实现集群的快速扩缩容？

答案：

# 添加 Master 节点
sealos add --masters 192.168.1.15

# 添加 Node 节点
sealos add --nodes 192.168.1.16,192.168.1.17

# 删除 Master 节点
sealos delete --masters 192.168.1.15

# 删除 Node 节点
sealos delete --nodes 192.168.1.16

添加节点流程：

graph TD
    S1["1. SealOS CLI 连接到新节点"] --> S2["2. 分发 Kubernetes 二进制和配置文件"]
    S2 --> S3["3. 分发集群证书（kubelet、kube-proxy）"]
    S3 --> S4["4. 启动 kubelet 服务"]
    S4 --> S5["5. 节点加入集群"]
    S5 --> S6["6. 更新 lvscare 负载均衡配置"]

6 SealOS 如何实现集群升级？

答案：

# 查看当前版本
kubectl version

# 升级到指定版本
sealos upgrade --image labring/kubernetes:v1.29.0

# 指定升级策略
sealos upgrade --image labring/kubernetes:v1.29.0 \
  --parallel 2 \                    # 并行升级节点数
  --force                           # 强制升级

升级流程：

graph TD
    S1["1. 拉取新版本镜像"] --> S2["2. 升级 Master 节点（逐个）"]
    S2 --> S2a["排空（drain）节点"]
    S2a --> S2b["升级 kubelet/kubeadm"]
    S2b --> S2c["升级 API Server 等控制面组件"]
    S2c --> S2d["恢复调度（uncordon）"]
    S2d --> S3["3. 升级 Node 节点（并行，可配置）"]
    S3 --> S4["4. 更新集群版本状态"]

7 SealOS 如何备份和恢复集群？

答案：

# 备份集群（包含 etcd）
sealos backup --name my-backup

# 指定备份存储
sealos backup --name my-backup \
  --path /data/backup/k8s

# 从备份恢复
sealos restore --name my-backup

# 从指定路径恢复
sealos restore --name my-backup --path /data/backup/k8s

备份内容：

etcd 快照（集群状态）
PKI 证书（CA、API Server 等）
kubeadm 配置
集群网络配置

8 SealOS 的应用商店（App Store）机制是怎样的？

答案：

SealOS 提供应用商店功能，一键部署复杂分布式应用。

# 安装 MySQL 集群
sealos run labring/mysql-cluster:8.0

# 安装 Redis 集群
sealos run labring/redis-cluster:7.0

# 安装 Prometheus 监控栈
sealos run labring/kube-prometheus-stack:v0.70.0

应用镜像示例（MySQL 集群）：

# Kubefile
FROM scratch
COPY manifests manifests/
COPY registry registry/
CMD ["kubectl apply -f manifests/"]
# manifests/mysql-cluster.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: mysql-cluster
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
  namespace: mysql-cluster
spec:
  replicas: 3
  serviceName: mysql
  template:
    spec:
      containers:
      - name: mysql
        image: mysql:8.0

9 SealOS 如何处理 SSH 免密认证和多节点配置？

答案：

# Clusterfile SSH 配置
spec:
  ssh:
    user: root
    # 方式 1：密码
    passwd: "your-password"
    # 方式 2：私钥
    pk: /root/.ssh/id_rsa
    pkPasswd: "key-password"  # 密钥密码（可选）
    port: 22

自动分发 SSH 密钥：

# 指定密码，SealOS 自动配置所有节点 SSH 互信
sealos run labring/kubernetes:v1.28.0 \
  --masters 192.168.1.10 \
  --nodes 192.168.1.11,192.168.1.12 \
  --user root \
  --passwd 'your-password'

10 SealOS 与 kubeadm 的核心区别是什么？

答案：

维度	kubeadm	SealOS
安装命令	`kubeadm init` + 手动 CNI	`sealos run` 一行命令
HA 负载均衡	需外部工具（HAProxy/Nginx）	内置 lvscare（LVS）
节点管理	`kubeadm join` 手动 token	`sealos add/delete` 自动
证书管理	手动或 cert-manager	自动
内置仓库	无	内置本地仓库
应用安装	Helm/Kubectl 手动	`sealos run` 应用镜像
升级	kubeadm upgrade 多步	`sealos upgrade` 单命令
备份恢复	etcdctl 手动	`sealos backup/restore`
多云兼容	无差异	支持阿里云/AWS/裸金属

选型建议：

已有集群手动运维经验：kubeadm 灵活可控
快速部署、统一管理：SealOS 自动化

11 SealOS 的 Clusterfile 支持哪些配置？

答案：

apiVersion: sealos.io/v1beta1
kind: Cluster
metadata:
  name: prod-cluster
spec:
  hosts:
  - ips: [192.168.1.10, 192.168.1.11, 192.168.1.12]
    roles: [master]
  - ips: [192.168.1.13, 192.168.1.14, 192.168.1.15]
    roles: [node]
  image: labring/kubernetes:v1.28.0
  ssh:
    user: root
    passwd: "password"
    port: 22
apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: kubeadm
spec:
  path: etc/init.sh
  data: |
    # 自定义初始化脚本
    sysctl -w net.bridge.bridge-nf-call-iptables=1
    sysctl -w net.ipv4.ip_forward=1    
apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: calico
spec:
  path: manifests/calico-custom.yaml
  data: |
    # 自定义 CNI 配置

12 SealOS 如何处理 Kubernetes 组件的容器化？

答案：

SealOS 将 Kubernetes 组件（kube-apiserver、kube-scheduler 等）打包为静态 Pod 或系统服务运行。

# SealOS 安装后查看组件
kubectl -n kube-system get pods
# kube-apiserver          # 静态 Pod
# kube-controller-manager # 静态 Pod
# kube-scheduler          # 静态 Pod
# etcd                    # 静态 Pod
# coredns                 # Deployment

组件运行方式：

Master 组件以静态 Pod 运行在 /etc/kubernetes/manifests/ 下
kubelet 以 Systemd Service 运行
CRI 使用 containerd（默认）或 Docker
镜像从内置仓库拉取

13 SealOS 在公有云环境（阿里云/AWS）的使用方式？

答案：

# 阿里云 ECS 一键创建集群
sealos run labring/kubernetes:v1.28.0 \
  --masters 192.168.1.10,192.168.1.11 \
  --nodes 192.168.1.12,192.168.1.13 \
  --provider aliyun

# AWS EC2
sealos run labring/kubernetes:v1.28.0 \
  --masters 10.0.1.10,10.0.1.11 \
  --nodes 10.0.1.12,10.0.1.13 \
  --provider aws

云 Provider 功能：

自动创建 SLB（阿里云）/ NLB（AWS）
自动配置安全组/防火墙规则
自动管理 EIP 和 DNS

14 SealOS 如何处理 etcd 的高可用和运维？

答案：

SealOS 自动配置 etcd 集群，无需手动设置。

# 查看 etcd 成员
kubectl -n kube-system exec etcd-master-0 -- etcdctl member list

# backup etcd（通过 sealos backup 已包含）
sealos backup

# 手动 etcd 快照
kubectl -n kube-system exec etcd-master-0 -- \
  etcdctl snapshot save /var/lib/etcd/snapshot.db

etcd 配置：

3 个 Master 自动组成 3 节点 etcd 集群
使用 TLS 证书加密通信
数据存储在 /var/lib/etcd

15 SealOS 的内置镜像仓库是如何工作的？

答案：

SealOS 在每个 Master 节点上部署轻量级镜像仓库。

# 仓库地址（默认）
# registry.{cluster-name}.svc.cluster.local:5000
# 或本地端口 5000

# 推送自定义镜像
docker tag myapp:latest localhost:5000/myapp:latest
docker push localhost:5000/myapp:latest

# 节点上 image-cri-shim 自动将仓库地址替换为本地仓库
# 加速镜像拉取，减少外网带宽

仓库工作原理：

graph LR
    Pod["Pod 创建"] --> Kubelet["kubelet 拉取镜像"]
    Kubelet --> Shim["image-cri-shim"]
    Shim --> Check{"检查镜像是否在本地仓库"}
    Check -->|"存在"| Local["直接拉取本地（内网）"]
    Check -->|"不存在"| Remote["从外网拉取"]
    Remote --> Sync["同步到本地仓库"]

16 SealOS 如何处理证书管理？

答案：

SealOS 自动生成和管理集群证书，有效期默认 100 年。

# 查看证书信息
openssl x509 -in /etc/kubernetes/pkg/ca.crt -text -noout

# 证书列表
# /etc/kubernetes/pki/
#   apiserver.crt / apiserver.key
#   apiserver-kubelet-client.crt / apiserver-kubelet-client.key
#   ca.crt / ca.key
#   front-proxy-ca.crt / front-proxy-ca.key
#   sa.key / sa.pub
#   etcd/ca.crt / etcd/server.crt

17 SealOS 的多集群管理能力如何？

答案：

SealOS 通过独立 Clusterfile 管理多集群，每个集群一个配置。

# 管理多个集群的配置文件
# - ~/.sealos/cluster/prod-cluster.yaml
# - ~/.sealos/cluster/staging-cluster.yaml
# - ~/.sealos/cluster/dev-cluster.yaml

# 切换到不同集群
export SEALOS_CLUSTER=staging-cluster
sealos status

# 或使用 kubeconfig
export KUBECONFIG=/root/.sealos/staging-cluster/etc/kubeconfig

18 SealOS 如何支持离线部署？

答案：

SealOS 的镜像机制天然支持离线部署场景。

# 在联网环境拉取镜像
sealos pull labring/kubernetes:v1.28.0
sealos pull labring/calico:v3.26.0

# 保存为 tar 包
sealos save -o k8s-offline.tar labring/kubernetes:v1.28.0
sealos save -o calico-offline.tar labring/calico:v3.26.0

# 在离线环境导入
sealos load -i k8s-offline.tar
sealos load -i calico-offline.tar

# 部署离线集群
sealos run labring/kubernetes:v1.28.0 labring/calico:v3.26.0 \
  --masters 192.168.1.10 \
  --nodes 192.168.1.11,192.168.1.12

离线部署优势：

一张应用镜像包含所有组件和依赖
无需外网访问容器仓库
适合内网和涉密环境

19 SealOS 如何收集集群诊断信息？

答案：

# 集群诊断
sealos debug

# 收集诊断日志
sealos debug --output /tmp/cluster-debug.tar.gz

# 节点健康检查
sealos status

# 查看节点状态
sealos nodes ls

20 SealOS 与 Rancher / KubeSpray 的核心差异？

答案：

维度	SealOS	Rancher	KubeSpray
架构	单 CLI 工具	C/S（Rancher Server + 集群）	Ansible Playbook
部署方式	应用镜像	UI/API	命令行 Ansible
镜像封装	OCI 应用镜像	Helm Charts	无
HA 方案	lvscare (LVS)	外部 LB	Keepalived
升级	sealos upgrade	Rancher UI	Ansible Playbook
应用商店	内置	内置（Rancher Apps）	无
离线支持	天然支持	需手动同步	需自行配置
资源占用	极低	需要 Rancher Server	无额外组件
学习曲线	低	中	高（需了解 Ansible）

选型建议：

追求简洁快速部署：SealOS
需要企业级管理界面：Rancher
已有 Ansible 基础设施：KubeSpray

21 SealOS 的 ClusterImage 与 OCI 镜像规范的关系是什么？

答案：

SealOS 的 ClusterImage 完全兼容 OCI（Open Container Initiative）镜像规范，将 Kubernetes 集群及其依赖打包为标准容器镜像。

OCI 规范兼容性：

镜像层（layers）：每个组件（K8s 二进制、CNI 插件、容器镜像）作为一个独立层存储
镜像清单（manifest）：符合 application/vnd.oci.image.manifest.v1+json 格式
镜像配置（config）：包含集群元数据、版本信息和运行指令
分发协议：通过标准 OCI Registry 协议推拉镜像（支持 Docker Hub、Harbor、私有仓库）

ClusterImage 分层结构：

graph TD
    Root["labring/kubernetes:v1.28.0"]
    Root --> L0["Layer 0: Base OS 依赖（libseccomp、socat、conntrack 等）"]
    Root --> L1["Layer 1: CRI 运行时（containerd 二进制 + systemd 配置）"]
    Root --> L2["Layer 2: K8s 组件（kubelet、kubeadm、kubectl 二进制）"]
    Root --> L3["Layer 3: 容器镜像（kube-apiserver、etcd、coredns 等）"]
    Root --> L4["Layer 4: 集群配置（Clusterfile 模板、kubeadm 配置）"]
    Root --> L5["Layer 5: 初始化脚本与管理工具"]
    Root --> LN["Layer N: 自定义扩展（CNI、Ingress、监控等）"]

Kubefile 构建流程：

# Kubefile 类比 Dockerfile，集群镜像构建文件
FROM labring/kubernetes:v1.28.0

# COPY 指令添加文件到镜像层
COPY ./runtimes/containerd /usr/local/bin/
COPY ./cni/custom-calico ./images/

# RUN 在构建时执行命令
RUN wget https://github.com/containerd/containerd/releases/download/v1.7.0/containerd-1.7.0-linux-amd64.tar.gz

# CMD 集群部署完成后执行的命令
CMD ["kubectl apply -f manifests/custom-resources.yaml"]

# 构建镜像
sealos build -t myrepo/kubernetes:v1.28.0-custom -f Kubefile .

# 推送到远程仓库
sealos push myrepo/kubernetes:v1.28.0-custom

# 从远程仓库拉取
sealos pull myrepo/kubernetes:v1.28.0-custom

与 Docker 镜像的差异：

维度	Docker 镜像	ClusterImage
运行目标	单个容器	整个 K8s 集群
内容	应用 + 运行时依赖	K8s 组件 + CRI + CNI + 容器镜像 + 配置
分层粒度	按 Dockerfile 指令分层	按组件功能分层
分发单元	单容器实例	完整集群环境
版本管理	应用版本	K8s 版本 + 生态组件版本

22 SealOS 如何配置容器运行时（containerd / cri-o / docker）？

答案：

SealOS 默认使用 containerd 作为容器运行时，支持通过 Clusterfile 自定义运行时配置。

默认 containerd 配置：

# Clusterfile 中指定运行时
apiVersion: sealos.io/v1beta1
kind: Cluster
metadata:
  name: containerd-cluster
spec:
  hosts:
  - ips: [192.168.1.10, 192.168.1.11]
    roles: [master]
  - ips: [192.168.1.12, 192.168.1.13]
    roles: [node]
  image: labring/kubernetes:v1.28.0
apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: containerd-config
spec:
  path: etc/containerd-config.toml
  data: |
    version = 2
    [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc]
      runtime_type = "io.containerd.runc.v2"
    [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
      SystemdCgroup = true
    [plugins."io.containerd.grpc.v1.cri"]
      sandbox_image = "registry.k8s.io/pause:3.9"

切换到 cri-o 运行时：

apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: cri-o-runtime
spec:
  path: etc/crio-setup.sh
  data: |
    #!/bin/bash
    # 安装 cri-o
    OS=xUbuntu_22.04
    CRIO_VERSION=1.28
    echo "deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/$OS/ /" \
      > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list
    echo "deb http://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable:/cri-o:/$CRIO_VERSION/$OS/ /" \
      > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable:cri-o:$CRIO_VERSION.list
    apt-get update && apt-get install -y cri-o cri-o-runc
    systemctl enable crio --now

使用 Docker 作为运行时（需 cri-dockerd）：

apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: docker-runtime
spec:
  path: etc/kubeadm-init.sh
  data: |
    # 在 kubeadm 初始化前安装 cri-dockerd
    wget https://github.com/Mirantis/cri-dockerd/releases/download/v0.3.4/cri-dockerd_0.3.4.3-0.ubuntu-jammy_amd64.deb
    dpkg -i cri-dockerd_0.3.4.3-0.ubuntu-jammy_amd64.deb
    # 修改 kubeadm 配置使用 cri-dockerd socket
    sed -i 's|/run/containerd/containerd.sock|/run/cri-dockerd.sock|' /etc/kubeadm.yml

运行时配置最佳实践：

配置项	推荐值	说明
SystemdCgroup	true	与 kubelet 的 cgroup 驱动一致
sandbox_image	registry.k8s.io/pause:3.9	沙箱容器镜像
runtime_type	io.containerd.runc.v2	默认 OCI 运行时
registry-mirrors	私有仓库地址	加速镜像拉取

23 SealOS 如何集成自定义 CNI（Calico / Cilium / Flannel）？

答案：

SealOS 通过 Clusterfile 中的 Config 资源或自定义 Kubefile 集成 CNI 插件。

方式一：使用官方 CNI 镜像（推荐）：

# Calico
sealos run labring/kubernetes:v1.28.0 labring/calico:v3.26.0 \
  --masters 192.168.1.10,192.168.1.11 \
  --nodes 192.168.1.12,192.168.1.13

# Cilium
sealos run labring/kubernetes:v1.28.0 labring/cilium:v1.14.0 \
  --masters 192.168.1.10 \
  --nodes 192.168.1.11,192.168.1.12

方式二：Clusterfile 自定义 CNI 配置：

apiVersion: sealos.io/v1beta1
kind: Cluster
metadata:
  name: cilium-cluster
spec:
  hosts:
  - ips: [192.168.1.10, 192.168.1.11]
    roles: [master]
  - ips: [192.168.1.12, 192.168.1.13]
    roles: [node]
  image: labring/kubernetes:v1.28.0
apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: cilium-custom
spec:
  strategy: merge
  path: manifests/cilium-values.yaml
  data: |
    # 在集群初始化前应用自定义 CNI
    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: cilium-config
    data:
      enable-ipv4: "true"
      enable-bpf-masquerade: "true"
      enable-bandwidth-manager: "true"
      kube-proxy-replacement: "strict"
      ipam-mode: "cluster-pool"
      cluster-pool-ipv4-cidr: "10.42.0.0/16"

方式三：自定义 Kubefile 打包 CNI：

# Kubefile
FROM labring/kubernetes:v1.28.0

# 添加 Cilium 镜像到内置仓库
COPY images/cilium-operator.tar ./registry/
COPY images/cilium-agent.tar ./registry/

# 添加 Cilium Helm Chart
COPY charts/cilium ./charts/

# 部署 Cilium
CMD ["helm install cilium ./charts/cilium \
  --namespace kube-system \
  --set ipam.mode=kubernetes \
  --set kubeProxyReplacement=strict \
  --set hubble.relay.enabled=true \
  --set hubble.ui.enabled=true"]

sealos build -t myrepo/kubernetes-cilium:v1.28.0 -f Kubefile .
sealos run myrepo/kubernetes-cilium:v1.28.0 \
  --masters 192.168.1.10,192.168.1.11 \
  --nodes 192.168.1.12

CNI 选型对比：

特性	Calico	Cilium	Flannel
数据面	iptables / eBPF	eBPF	VXLAN / host-gw
网络策略	丰富（GlobalNetworkPolicy）	丰富（L3-L7）	基础
性能	高	极高（eBPF）	中
可观测性	基础	Hubble（L7 流量可视化）	无
服务网格	无	内置（无 Sidecar）	无
SealOS 集成	labring/calico 镜像	labring/cilium 镜像	手动配置

24 SealOS 的内置 Registry 如何与 Harbor 集成？

答案：

SealOS 的内置 Registry 可与 Harbor 集成，实现企业级镜像管理和安全扫描。

集成架构：

graph TD
    Kubelet["kubelet"] --> Shim["image-cri-shim"]
    Shim --> Reg["内置 Registry (localhost:5000)"]
    Reg -->|"缓存未命中时"| Harbor["外部 Harbor (harbor.company.com)"]
    Harbor --> Scan["镜像安全扫描（Trivy / Clair）"]
    Harbor --> Sign["镜像签名验证（Notary / Cosign）"]
    Harbor --> RBAC["访问控制（RBAC + LDAP）"]
    Harbor --> Rep["镜像复制与同步"]

配置镜像代理缓存：

# 内置 Registry 配置代理到 Harbor
apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: registry-proxy
spec:
  path: etc/registry-config.yml
  data: |
    version: 0.1
    proxy:
      remoteurl: https://harbor.company.com
      username: sealos-proxy
      password: Harbor12345
    storage:
      filesystem:
        rootdirectory: /var/lib/registry

# 重启 Registry 使配置生效
kubectl -n sealos-system rollout restart deployment/registry

Harbor 复制规则实现镜像同步：

# Harbor 侧创建复制规则
# 将 labring/kubernetes 等镜像从 Docker Hub 同步到 Harbor
# 项目：public → 目标：harbor.company.com/sealos

# SealOS 指向 Harbor 仓库
sealos run harbor.company.com/sealos/kubernetes:v1.28.0 \
  harbor.company.com/sealos/calico:v3.26.0 \
  --masters 192.168.1.10 \
  --nodes 192.168.1.11,192.168.1.12

Harbor 集成安全策略：

策略	配置	说明
镜像扫描	Trivy 自动扫描	阻止含有高危漏洞的镜像部署
镜像签名	Cosign 签名验证	仅允许经过签名的镜像运行
访问控制	Harbor RBAC	限制特定项目/镜像的拉取权限
配额管理	项目级存储配额	限制镜像仓库存储空间
垃圾回收	定期 GC	清理未引用的镜像层

25 SealOS 如何进行集群证书自动续签？

答案：

SealOS 默认生成 100 年有效期的证书，实质上消除了手动续签需求。对于短有效期证书或合规场景，支持集成 cert-manager 实现自动续签。

SealOS 证书策略：

# 查看证书有效期
kubeadm certs check-expiration

# SealOS 生成的证书
# /etc/kubernetes/pki/ca.crt              100 年有效期
# /etc/kubernetes/pki/apiserver.crt       100 年有效期
# /etc/kubernetes/pki/apiserver-kubelet-client.crt  100 年有效期

使用 kubeadm 手动续签：

# 续签所有证书（传统 kubeadm 方式）
kubeadm certs renew all

# 续签指定证书
kubeadm certs renew apiserver
kubeadm certs renew apiserver-kubelet-client

# 重启控制面组件使证书生效
crictl pods | grep kube-apiserver | awk '{print $1}' | xargs crictl stopp

集成 cert-manager 自动管理证书：

# 在集群部署模板中集成 cert-manager
# Kubefile
FROM labring/kubernetes:v1.28.0

COPY images/cert-manager ./registry/
COPY manifests/cert-manager.yaml ./manifests/

CMD ["sh", "-c", "
  kubectl apply -f manifests/cert-manager.yaml &&
  kubectl wait --for=condition=Available deployment/cert-manager -n cert-manager --timeout=300s
"]

# 自动续签 kubelet 服务证书
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: kubelet-serving
  namespace: kube-system
spec:
  secretName: kubelet-serving-cert
  duration: 2160h  # 90 天
  renewBefore: 360h  # 到期前 15 天自动续签
  issuerRef:
    name: ca-issuer
    kind: Issuer
  dnsNames:
  - "*.cluster.local"

轮换 CA 证书（极端场景）：

# 1. 备份现有证书
cp -r /etc/kubernetes/pki /etc/kubernetes/pki.bak

# 2. 生成新 CA
kubeadm init phase certs all --config kubeadm-config.yaml

# 3. 更新所有组件证书
kubeadm init phase kubeconfig all --config kubeadm-config.yaml

# 4. 滚动重启控制面
crictl pods --namespace kube-system | grep -E 'kube-apiserver|kube-controller|kube-scheduler' \
  | awk '{print $1}' | xargs -I {} crictl stopp {}

26 SealOS 的故障恢复与节点替换流程是怎样的？

答案：

SealOS 支持 Master 节点和 Worker 节点的故障替换，并提供 etcd 成员故障恢复能力。

Worker 节点故障恢复：

# 移除故障节点
sealos delete --nodes 192.168.1.14

# 加入新节点替换
sealos add --nodes 192.168.1.15

Master 节点故障恢复：

# 1. 从集群中移除故障 Master
sealos delete --masters 192.168.1.11

# 2. 清理残留的 etcd 成员
kubectl -n kube-system exec -it etcd-192.168.1.10 -- etcdctl \
  --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key \
  member remove <故障节点ID>

# 3. 加入新 Master 节点
sealos add --masters 192.168.1.16

etcd 故障恢复流程：

# 场景：多数 etcd 节点故障，从快照恢复
# 1. 停止所有控制面组件
mv /etc/kubernetes/manifests /etc/kubernetes/manifests.bak

# 2. 从快照恢复 etcd 数据
ETCDCTL_API=3 etcdctl snapshot restore /backup/etcd-snapshot.db \
  --name master-0 \
  --initial-cluster "master-0=https://192.168.1.10:2380" \
  --initial-advertise-peer-urls https://192.168.1.10:2380 \
  --data-dir /var/lib/etcd-restore

# 3. 替换数据目录并启动 etcd
mv /var/lib/etcd /var/lib/etcd.bak
mv /var/lib/etcd-restore /var/lib/etcd

# 4. 恢复控制面组件
mv /etc/kubernetes/manifests.bak /etc/kubernetes/manifests

# 5. 重建其他 Master 节点
sealos add --masters 192.168.1.11,192.168.1.12

节点替换步骤详解：

graph TD
    subgraph Remove["删除节点流程"]
        R1["1. kubectl drain --ignore-daemonsets --delete-emptydir-data"]
        R2["2. kubectl delete node"]
        R3["3. SSH 到目标节点，kubeadm reset"]
        R4["4. 清理网络配置和 iptables 规则"]
        R5["5. 如果该节点是 etcd 成员，从 etcd 集群中移除"]
        R1 --> R2 --> R3 --> R4 --> R5
    end
    subgraph Add["添加节点流程"]
        A1["1. SSH 连接到新节点"]
        A2["2. 安装 CRI 运行时（containerd）"]
        A3["3. 分发 K8s 二进制与配置文件"]
        A4["4. 分发集群证书"]
        A5["5. kubeadm join 或 kubeadm init（Master）"]
        A6["6. 更新 lvscare 负载均衡配置"]
        A7["7. 等待节点 Ready"]
        A1 --> A2 --> A3 --> A4 --> A5 --> A6 --> A7
    end

27 SealOS 如何支持多架构（amd64 / arm64）混合集群？

答案：

SealOS 的 OCI 镜像机制天然支持多架构集群，通过 manifest list 实现跨架构部署。

多架构镜像构建：

# 在 amd64 机器上构建
sealos build -t myrepo/kubernetes:v1.28.0-amd64 -f Kubefile .

# 在 arm64 机器上构建
sealos build -t myrepo/kubernetes:v1.28.0-arm64 -f Kubefile .

# 创建 manifest list
sealos manifest create myrepo/kubernetes:v1.28.0
sealos manifest add myrepo/kubernetes:v1.28.0 \
  myrepo/kubernetes:v1.28.0-amd64 \
  myrepo/kubernetes:v1.28.0-arm64

# 推送 manifest list
sealos manifest push myrepo/kubernetes:v1.28.0

多架构集群部署：

# Clusterfile 混合架构集群
apiVersion: sealos.io/v1beta1
kind: Cluster
metadata:
  name: hybrid-cluster
spec:
  hosts:
  # amd64 Master 节点
  - ips: [192.168.1.10, 192.168.1.11]
    roles: [master]
    arch: amd64
  # arm64 Worker 节点
  - ips: [192.168.1.20, 192.168.1.21, 192.168.1.22]
    roles: [node]
    arch: arm64
  image: myrepo/kubernetes:v1.28.0
  ssh:
    user: root
    passwd: "password"

混合架构注意事项：

关注点	说明
容器镜像	应用镜像需同时构建 amd64 和 arm64 版本
节点亲和性	使用 nodeAffinity 将特定架构的应用调度到对应节点
CNI 插件	Calico / Cilium / Flannel 均已支持 arm64
containerd	需安装对应架构的 containerd 二进制
性能差异	arm64 节点（如 Graviton）可能提供更优性价比
镜像仓库	Harbor 等仓库需支持多架构 manifest

节点亲和性配置示例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: multi-arch-app
spec:
  template:
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: kubernetes.io/arch
                operator: In
                values: [amd64]
      containers:
      - name: app
        image: myapp:v1.0  # 多架构镜像

28 SealOS 与 k3s 的核心差异是什么？

答案：

SealOS 定位为云操作系统，k3s 定位为轻量级 K8s 发行版，二者在架构理念、资源占用和适用场景上有本质差异。

核心对比：

维度	SealOS	k3s
定位	云操作系统（集群生命周期管理）	轻量级 Kubernetes 发行版
安装方式	sealos run（应用镜像）	curl 脚本一键安装
二进制大小	CLI 工具约 30MB	单二进制约 60MB（含所有组件）
组件运行	标准静态 Pod（kube-apiserver 等）	进程内嵌（apiserver 内嵌 kine）
默认存储	etcd（标准 3 节点）	SQLite（单节点）/ etcd（HA）
默认 CNI	用户选择（Calico / Cilium / Flannel）	Flannel
默认 CRI	containerd	containerd
HA 方案	lvscare（LVS 负载均衡）	内嵌 Dqlite 或外部 etcd
资源占用	标准 K8s 资源	极低（512MB 内存可运行）
集群规模	数千节点	数百节点
应用商店	内置（sealos run 应用镜像）	无（需 Helm）
离线部署	天然支持（镜像打包）	需手动同步
升级	sealos upgrade	手动替换二进制

选型建议：

场景	推荐	原因
边缘计算（IoT / 嵌入式）	k3s	资源占用极低，单二进制运行
开发环境 / CI	k3s	快速启动，适合短暂生命周期
生产级多节点集群	SealOS	标准化 etcd、完善的 HA 方案
大规模集群管理	SealOS	内置扩缩容、备份恢复、健康检查
离线 / 涉密环境	SealOS	ClusterImage 打包所有依赖
快速原型验证	k3s	一条命令安装，30 秒可用

29 SealOS 生产环境部署有哪些最佳实践？

答案：

生产环境部署 SealOS 集群需覆盖网络规划、节点规格、高可用、安全加固和监控五个维度。

网络规划：

# 生产环境 Clusterfile 示例
apiVersion: sealos.io/v1beta1
kind: Cluster
metadata:
  name: prod-k8s-cluster
spec:
  hosts:
  # 3 个 Master（跨机架/可用区）
  - ips: [10.10.1.10, 10.10.2.10, 10.10.3.10]
    roles: [master]
  # N 个 Worker（按业务分组）
  - ips: [10.10.1.21, 10.10.1.22, 10.10.1.23]
    roles: [node]
    labels:
      node-role: general
  - ips: [10.10.2.21, 10.10.2.22]
    roles: [node]
    labels:
      node-role: high-memory
  image: labring/kubernetes:v1.28.0
  ssh:
    user: root
    pk: /root/.ssh/id_rsa
    port: 22

生产环境检查清单：

维度	配置项	推荐值	说明
Master 节点	数量	3 或 5（奇数）	保证 etcd 仲裁
etcd	磁盘	SSD，独立分区	IOPS >= 5000
CNI	插件	Calico / Cilium	生产验证充分
CRI	运行时	containerd	SystemdCgroup=true
内核参数	ip_forward	1	必须开启
内核参数	bridge-nf-call-iptables	1	必须开启
防火墙	6443、2379-2380、10250	开放	API Server、etcd、kubelet
时间同步	chrony / ntpd	已配置	证书依赖准确时间
swap	状态	关闭	kubelet 强制要求
SELinux	状态	permissive 或 disabled	避免策略干扰

内核参数预配置：

apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: kernel-params
spec:
  path: etc/sysctl.sh
  data: |
    #!/bin/bash
    cat <<EOF > /etc/sysctl.d/99-kubernetes.conf
    net.bridge.bridge-nf-call-iptables = 1
    net.bridge.bridge-nf-call-ip6tables = 1
    net.ipv4.ip_forward = 1
    net.ipv4.tcp_tw_reuse = 1
    net.ipv4.ip_local_port_range = 1024 65000
    fs.file-max = 2097152
    fs.inotify.max_user_instances = 8192
    fs.inotify.max_user_watches = 524288
    vm.swappiness = 0
    vm.overcommit_memory = 1
    kernel.panic = 10
    kernel.panic_on_oops = 1
    EOF
    sysctl --system

备份策略：

# 定时 etcd 备份（CronJob）
# 每 6 小时执行一次 etcd 快照
0 */6 * * * sealos backup --name prod-backup-$(date +\%Y\%m\%d-\%H\%M)

# 备份保留策略
# 最近 7 天的每日备份 + 最近 4 周的每周备份

30 SealOS 如何支持 GPU 节点？

答案：

SealOS 通过 Clusterfile 的 Config 机制注入 GPU 驱动和 Device Plugin，支持 NVIDIA GPU 节点。

GPU 节点部署流程：

# Clusterfile 配置 GPU 节点
apiVersion: sealos.io/v1beta1
kind: Cluster
metadata:
  name: gpu-cluster
spec:
  hosts:
  - ips: [192.168.1.10, 192.168.1.11]
    roles: [master]
  - ips: [192.168.1.12]
    roles: [node]
    labels:
      accelerator: nvidia-t4
  - ips: [192.168.1.13, 192.168.1.14]
    roles: [node]
    labels:
      accelerator: nvidia-a100
  image: labring/kubernetes:v1.28.0
apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: nvidia-gpu-setup
spec:
  path: etc/gpu-setup.sh
  data: |
    #!/bin/bash
    # 安装 NVIDIA 驱动
    distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
    curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | apt-key add -
    curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list \
      > /etc/apt/sources.list.d/nvidia-docker.list

    apt-get update && apt-get install -y nvidia-container-toolkit

    # 配置 containerd 支持 GPU
    nvidia-ctk runtime configure --runtime=containerd
    systemctl restart containerd    
apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: nvidia-device-plugin
spec:
  strategy: merge
  path: manifests/nvidia-plugin.yaml
  data: |
    apiVersion: apps/v1
    kind: DaemonSet
    metadata:
      name: nvidia-device-plugin-daemonset
      namespace: kube-system
    spec:
      selector:
        matchLabels:
          name: nvidia-device-plugin-ds
      template:
        metadata:
          labels:
            name: nvidia-device-plugin-ds
        spec:
          tolerations:
          - key: nvidia.com/gpu
            operator: Exists
            effect: NoSchedule
          containers:
          - name: nvidia-device-plugin-ctr
            image: nvcr.io/nvidia/k8s-device-plugin:v0.14.0
            securityContext:
              allowPrivilegeEscalation: false
              capabilities:
                drop: ["ALL"]

GPU 工作负载配置：

apiVersion: v1
kind: Pod
metadata:
  name: gpu-training-job
spec:
  nodeSelector:
    accelerator: nvidia-t4
  containers:
  - name: training
    image: nvcr.io/nvidia/pytorch:23.10-py3
    resources:
      limits:
        nvidia.com/gpu: 2  # 申请 2 块 GPU
    env:
    - name: NVIDIA_VISIBLE_DEVICES
      value: all

GPU 支持组件链：

graph TD
    subgraph Host["主机层"]
        Driver["NVIDIA Driver ≥ 470.x"]
        Toolkit["nvidia-container-toolkit"]
    end
    subgraph Runtime["容器运行时层"]
        Containerd["containerd (nvidia-container-runtime 作为 runtime)"]
    end
    subgraph K8s["Kubernetes 层"]
        Plugin["nvidia-device-plugin (DaemonSet)"]
    end
    subgraph Schedule["调度层"]
        Selector["nodeSelector / nodeAffinity (accelerator label)"]
        Limits["Resource Limits (nvidia.com/gpu)"]
    end
    Host --> Runtime --> K8s --> Schedule

31 SealOS 的安全加固配置有哪些要点？

答案：

SealOS 集群安全加固覆盖操作系统层、Kubernetes 层、网络层和运行时层。

操作系统层加固：

apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: os-hardening
spec:
  path: etc/os-hardening.sh
  data: |
    #!/bin/bash
    # 禁用不必要的服务
    systemctl disable --now cups avahi-daemon bluetooth

    # 配置审计规则
    cat <<EOF > /etc/audit/rules.d/k8s.rules
    -w /etc/kubernetes/ -p wa -k kubernetes_config
    -w /var/lib/kubelet/ -p wa -k kubelet_data
    -w /etc/cni/ -p wa -k cni_config
    EOF

    # 限制 SSH 访问
    sed -i 's/^#PermitRootLogin.*/PermitRootLogin prohibit-password/' /etc/ssh/sshd_config
    sed -i 's/^#PasswordAuthentication.*/PasswordAuthentication no/' /etc/ssh/sshd_config

    # 配置防火墙
    ufw default deny incoming
    ufw default allow outgoing
    ufw allow 22/tcp
    ufw allow 6443/tcp
    ufw allow 2379:2380/tcp
    ufw allow 10250/tcp
    ufw enable

Kubernetes 层安全加固：

# kubeadm 安全参数
apiVersion: kubeadm.k8s.io/v1beta3
kind: ClusterConfiguration
apiServer:
  extraArgs:
    # 禁止匿名访问
    anonymous-auth: "false"
    # 启用审计日志
    audit-log-path: /var/log/kubernetes/audit.log
    audit-log-maxage: "30"
    audit-log-maxbackup: "10"
    audit-log-maxsize: "100"
    # 启用加密 Provider
    encryption-provider-config: /etc/kubernetes/pki/encryption-config.yaml
    # 启用 Node 鉴权
    authorization-mode: Node,RBAC
    # TLS 最低版本
    tls-min-version: VersionTLS12

etcd 数据加密：

apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: etcd-encryption
spec:
  path: etc/encryption-config.yaml
  data: |
    apiVersion: apiserver.config.k8s.io/v1
    kind: EncryptionConfiguration
    resources:
    - resources:
      - secrets
      - configmaps
      providers:
      - aescbc:
          keys:
          - name: key1
            secret: <base64-encoded-32-byte-key>
      - identity: {}

Pod 安全策略（Pod Security Admission）：

apiVersion: v1
kind: Namespace
metadata:
  name: production
  labels:
    pod-security.kubernetes.io/enforce: restricted
    pod-security.kubernetes.io/audit: restricted
    pod-security.kubernetes.io/warn: restricted
apiVersion: sealos.io/v1beta1
kind: Config
metadata:
  name: network-policy-default-deny
spec:
  path: manifests/default-deny-netpol.yaml
  data: |
    apiVersion: networking.k8s.io/v1
    kind: NetworkPolicy
    metadata:
      name: default-deny-all
      namespace: production
    spec:
      podSelector: {}
      policyTypes:
      - Ingress
      - Egress

安全加固检查清单：

层级	配置项	要求
OS	SSH 密钥认证	禁用密码登录
OS	防火墙	仅开放必要端口
OS	SELinux / AppArmor	enforcing 模式
K8s	API Server	关闭匿名访问（–anonymous-auth=false）
K8s	etcd	启用 TLS + 数据加密
K8s	RBAC	最小权限原则
K8s	ServiceAccount	禁用自动挂载（默认）
K8s	Pod Security	enforce restricted 级别
网络	NetworkPolicy	默认拒绝 + 白名单
运行时	Seccomp	启用默认 Seccomp Profile
镜像	来源	仅信任签名镜像和特定仓库