云计算百科
云计算领域专业知识百科平台

别再背组件名词了:跟着「一次上线」把 K8s 讲明白

/* MD / 富文本中的 .toc(含博客园搬家等嵌套结构);.toc-box 在侧栏,不受影响 */
#content_views .toc,
/* 编辑器常在目录前后插入空 p(:empty 仍占 20px),一并去掉避免顶空隙 */
#content_views.markdown_views > p:empty:has(+ .toc),
#content_views.markdown_views > .toc + p:empty,
/* 富文本旧版目录标记 */
#content_views.htmledit_views #main-toc,
#content_views.htmledit_views #hr-toc,
#content_views.htmledit_views p[id*=\”-toc\”] {
display: none !important;
}
/* 目录去掉后,紧跟的首个标题不再多出一块上边距 */
#content_views.markdown_views > .toc + h1,
#content_views.markdown_views > .toc + h2,
#content_views.markdown_views > .toc + h3,
#content_views.markdown_views > .toc + h4,
#content_views.markdown_views > .toc + p:empty + h1,
#content_views.markdown_views > .toc + p:empty + h2,
#content_views.markdown_views > .toc + p:empty + h3,
#content_views.markdown_views > .toc + p:empty + h4 {
margin-top: 0 !important;
}

从一个 Spring Boot 应用的真实发布过程出发,把 Node / Pod / Service / Ingress / ConfigMap / Secret / Volume / Deployment / StatefulSet 串成一条线;再补上清单之外、但生产里真正决定它能不能活下来的那些东西。 全文 YAML 和命令都可以照着敲,不谈空概念。

文章目录

    • @[toc]
    • 写在前面:为什么组件表背了就忘
    • 一、先抓住一句话:K8s 是「期望状态 + 控制循环」
    • 二、全局地图:一条请求是怎么进来的
    • 三、用「一栋办公楼」给 9 个组件对上号
    • 四、逐个拆开讲:是什么、为什么、怎么写、哪里会踩坑
      • 4.1 Node:Pod 真正落脚的地方
      • 4.2 Pod:不是「容器的抽象」,而是一组共享环境的容器
      • 4.3 Deployment:管的是 ReplicaSet,不是直接管 Pod
      • 4.4 Service:靠「标签」找 Pod,不是把 Pod 装进服务里
      • 4.5 Ingress:一份「规则」,需要有人来执行
      • 4.6 ConfigMap / Secret:把配置从镜像里拿出来
      • 4.7 Volume:数据持久化其实是一整套对象
      • 4.8 StatefulSet:给每个副本一个「身份」
    • 五、清单之外,但生产里一定绕不开的 8 个东西
    • 六、动手:一次可以照着敲的上线
      • 6.1 发布与验证
      • 6.2 四组实验,比看十遍文档都管用
    • 七、出问题时,按这个顺序看
    • 八、什么时候其实不该上 K8s
    • 小结
      • 参考

写在前面:为什么组件表背了就忘

很多入门资料会给你一张清单:Node 是节点、Pod 是最小调度单元、Service 提供统一入口……每个字都认识,合起来还是不会用。

原因不是记性差,而是清单是「名词字典」,没有主线。K8s 里每一个对象,都是为了解决一个具体麻烦才被发明出来的:

遇到了什么麻烦于是有了什么
容器挂了没人管 Pod + 控制器
想开 3 个副本、还想不停机更新 Deployment
Pod 重建后 IP 变了,调用方写死 IP 就崩 Service
集群外的人要通过一个域名访问进来 Ingress
改个数据库地址就要重新打镜像 ConfigMap / Secret
容器一重启,里面写的数据全没了 Volume / PVC
有状态应用需要固定名字和固定磁盘 StatefulSet

所以本文换个讲法:假设你要把一个叫 order-api 的 Spring Boot 服务发布到集群里,让它能被外网访问、能扩缩容、Pod 挂了能自愈、改配置不用重新打包。沿着这条线走一遍,所有组件自然就各就各位了。


一、先抓住一句话:K8s 是「期望状态 + 控制循环」

这是理解所有组件的前提,比背十个名词都管用。

你用 kubectl 做的不是「启动一个容器」,而是向 API Server 提交一份期望状态(YAML),这份状态存进 etcd。集群里有一堆 Controller 在不停地做同一件事:

读取期望状态 → 对比实际状态 → 不一样就动手修正 → 再读 → 再对比 ……

这个循环叫 reconcile loop(调谐循环)。所以:

kubectl apply -f deploy.yaml
kubectl get pods -w

# 手动删掉一个 Pod
kubectl delete pod order-api-7d9f8c6b5-x2k4m
# 几秒后立刻冒出一个新 Pod —— 不是有人重启了,是 Deployment 的控制器发现「期望 3 个,实际 2 个」

理解了这一点,就会明白:Pod 是「被管理的」,Deployment 是「管别人的」,而 kubectl delete pod 从来不等于「关掉服务」。

顺带认识一下清单之外、但绕不开的几个角色(一句话版):

角色干什么
API Server 所有请求的唯一入口,kubectl 就是跟它打交道
etcd 存集群全部状态的账本
Scheduler 决定新 Pod 该落到哪台 Node 上
Controller Manager 跑各种调谐循环(Deployment、Node、Job……)
kubelet 每台 Node 上的工头,真正把容器拉起来
kube-proxy 维护 Service 的转发规则(iptables / IPVS / eBPF)

二、全局地图:一条请求是怎么进来的

#mermaid-svg-EZUtDek88Hs6SBUd{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-EZUtDek88Hs6SBUd .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-EZUtDek88Hs6SBUd .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-EZUtDek88Hs6SBUd .error-icon{fill:#552222;}#mermaid-svg-EZUtDek88Hs6SBUd .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-EZUtDek88Hs6SBUd .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-EZUtDek88Hs6SBUd .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-EZUtDek88Hs6SBUd .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-EZUtDek88Hs6SBUd .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-EZUtDek88Hs6SBUd .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-EZUtDek88Hs6SBUd .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-EZUtDek88Hs6SBUd .marker{fill:#333333;stroke:#333333;}#mermaid-svg-EZUtDek88Hs6SBUd .marker.cross{stroke:#333333;}#mermaid-svg-EZUtDek88Hs6SBUd svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-EZUtDek88Hs6SBUd p{margin:0;}#mermaid-svg-EZUtDek88Hs6SBUd .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-EZUtDek88Hs6SBUd .cluster-label text{fill:#333;}#mermaid-svg-EZUtDek88Hs6SBUd .cluster-label span{color:#333;}#mermaid-svg-EZUtDek88Hs6SBUd .cluster-label span p{background-color:transparent;}#mermaid-svg-EZUtDek88Hs6SBUd .label text,#mermaid-svg-EZUtDek88Hs6SBUd span{fill:#333;color:#333;}#mermaid-svg-EZUtDek88Hs6SBUd .node rect,#mermaid-svg-EZUtDek88Hs6SBUd .node circle,#mermaid-svg-EZUtDek88Hs6SBUd .node ellipse,#mermaid-svg-EZUtDek88Hs6SBUd .node polygon,#mermaid-svg-EZUtDek88Hs6SBUd .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-EZUtDek88Hs6SBUd .rough-node .label text,#mermaid-svg-EZUtDek88Hs6SBUd .node .label text,#mermaid-svg-EZUtDek88Hs6SBUd .image-shape .label,#mermaid-svg-EZUtDek88Hs6SBUd .icon-shape .label{text-anchor:middle;}#mermaid-svg-EZUtDek88Hs6SBUd .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-EZUtDek88Hs6SBUd .rough-node .label,#mermaid-svg-EZUtDek88Hs6SBUd .node .label,#mermaid-svg-EZUtDek88Hs6SBUd .image-shape .label,#mermaid-svg-EZUtDek88Hs6SBUd .icon-shape .label{text-align:center;}#mermaid-svg-EZUtDek88Hs6SBUd .node.clickable{cursor:pointer;}#mermaid-svg-EZUtDek88Hs6SBUd .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-EZUtDek88Hs6SBUd .arrowheadPath{fill:#333333;}#mermaid-svg-EZUtDek88Hs6SBUd .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-EZUtDek88Hs6SBUd .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-EZUtDek88Hs6SBUd .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-EZUtDek88Hs6SBUd .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-EZUtDek88Hs6SBUd .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-EZUtDek88Hs6SBUd .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-EZUtDek88Hs6SBUd .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-EZUtDek88Hs6SBUd .cluster text{fill:#333;}#mermaid-svg-EZUtDek88Hs6SBUd .cluster span{color:#333;}#mermaid-svg-EZUtDek88Hs6SBUd div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-EZUtDek88Hs6SBUd .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-EZUtDek88Hs6SBUd rect.text{fill:none;stroke-width:0;}#mermaid-svg-EZUtDek88Hs6SBUd .icon-shape,#mermaid-svg-EZUtDek88Hs6SBUd .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-EZUtDek88Hs6SBUd .icon-shape p,#mermaid-svg-EZUtDek88Hs6SBUd .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-EZUtDek88Hs6SBUd .icon-shape .label rect,#mermaid-svg-EZUtDek88Hs6SBUd .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-EZUtDek88Hs6SBUd .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-EZUtDek88Hs6SBUd .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-EZUtDek88Hs6SBUd :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

order.example.com

按 host + path 匹配

EndpointSlice 里的真实 Pod IP

注入环境变量或配置文件

挂载

调谐循环

改 replicas

用户浏览器

云负载均衡 / 入口

Ingress Controller读 Ingress 规则

Service: order-api稳定 ClusterIP:80

Pod A :8080

Pod B :8080

Pod C :8080

ConfigMap / Secret

PV / PVC 持久化卷

Deployment期望 3 副本

HPA

若编辑器不渲染 mermaid,记住这条文字链路即可: 域名 → 入口网关 →(Ingress 规则选 Service)→ Service 稳定 IP →(标签选择器找到的 Pod 列表)→ 容器端口。 而 Deployment / HPA / ConfigMap / Volume 都不在「请求路径」上,它们在旁边负责维持状态。

这里有个特别容易混的点:Ingress 不直接转发流量,Service 也不"装"Pod。Ingress 只是一份路由规则(要由 Ingress Controller 来执行),Service 只是一个稳定的虚拟 IP + 一组转发规则,真正承接请求的是 Pod 里的容器。


三、用「一栋办公楼」给 9 个组件对上号

组件办公楼类比它真正解决的问题
Node 楼里的一台台服务器(物理机或虚拟机) 提供 CPU / 内存 / 磁盘,是 Pod 真正跑的地方
Pod 一个工位上的一组进程,共用网口和文件柜 K8s 最小调度单位;同一 Pod 内容器共享网络命名空间与卷,能用 localhost 互通
Deployment 「保证这个岗位始终有 3 个人在」的班长 副本数、滚动更新、回滚;人不合适就换一个
Service 内线总机:工位换了人,分机号不变 Pod IP 会变会死,给调用方一个稳定的访问入口 + 负载均衡
Ingress 前台:按门牌(域名)和路径把访客引到对应部门 用一个公网入口把 HTTP 请求分发到多个 Service
ConfigMap 公告板上的普通通知 把非敏感配置从镜像里剥出来
Secret 带锁的抽屉(但锁很简易) 存放密码、证书、Token
Volume 外接硬盘柜 容器重启后数据还在
StatefulSet 固定工位编号 + 每人专属档案柜 给有状态应用稳定的名字、稳定的存储、有序启停

四、逐个拆开讲:是什么、为什么、怎么写、哪里会踩坑

4.1 Node:Pod 真正落脚的地方

一个 Node 可以是物理机也可以是虚拟机,上面跑着 kubelet、容器运行时和 kube-proxy。

kubectl get nodes -o wide
kubectl describe node <node-name> | grep -A8 "Allocated resources"

实际情况:你几乎不会直接指定「跑在哪台 Node」。调度器看的是资源是否够、节点标签、亲和性、污点容忍。运维上更关心的是资源水位,比如 kubectl top nodes 和节点上的 Allocatable。

4.2 Pod:不是「容器的抽象」,而是一组共享环境的容器

比「一个或几个容器的组合」更准确的说法是:Pod 是一组共享网络命名空间、共享存储卷、被一起调度的最小单元。

同一 Pod 内:

  • 共用一个 IP,容器之间用 localhost:端口 通信;
  • 可以挂同一个 Volume 互相传文件;
  • 一起被创建、一起被调度到同一台 Node、一起被销毁。

「一个 Pod 一般只跑一个容器」是惯例,不是规则。真实集群里 sidecar 很常见:日志采集(Fluent Bit / Filebeat)、服务网格代理(Envoy)、配置热加载容器。所以更实用的说法是:

一个 Pod = 1 个主容器 + 0~N 个辅助容器;只有必须共享网络或文件、且同生共死的进程才放进同一个 Pod。

另外一个必须记住的事实:Pod 是"耗材"。它的 IP 每次重建都会变,本地磁盘默认随 Pod 消失。Service 和 Volume 就是为这两件事存在的。

# 最小 Pod(实际很少直接写,一般由 Deployment 生成)
apiVersion: v1
kind: Pod
metadata:
name: demo
labels:
app: demo
spec:
containers:
– name: app
image: nginx:1.27
ports:
– containerPort: 80

4.3 Deployment:管的是 ReplicaSet,不是直接管 Pod

层级关系:Deployment → ReplicaSet → Pod。每次改 Pod 模板(比如换镜像),Deployment 会新建一个 ReplicaSet 并逐步把副本从旧的挪到新的,这就是滚动更新。

kubectl create deployment order-api –image=nginx:1.27 –replicas=3
kubectl set image deployment/order-api nginx=nginx:1.28
kubectl rollout status deployment/order-api
kubectl rollout history deployment/order-api
kubectl rollout undo deployment/order-api # 回滚

两个常见误解:

  • Deployment 提供的是副本控制 + 滚动更新 + 回滚;自动扩缩容不是它的功能,那是 HPA(见 5.5)。
  • Deployment 适合无状态应用:任意一个副本都能被替换、都能处理任意请求。一旦实例之间有身份差别(主从、分片、固定磁盘),就要考虑 StatefulSet。
  • 4.4 Service:靠「标签」找 Pod,不是把 Pod 装进服务里

    这是整篇最该弄明白的一处。

    apiVersion: v1
    kind: Service
    metadata:
    name: order–api
    spec:
    type: ClusterIP
    selector:
    app: order–api # ← 关键:按标签挑 Pod,而不是列 IP
    ports:
    – port: 80 # Service 对内的端口
    targetPort: 8080 # 容器实际监听的端口

    Service 创建后,K8s 会持续把「带 app=order-api 标签且就绪的 Pod」写进 EndpointSlice,转发规则据此更新。所以扩容、重启、滚动更新时,Service 完全不用改。

    kubectl get endpointslices -l kubernetes.io/service-name=order-api -o wide

    四种类型怎么选:

    类型暴露范围实际用途
    ClusterIP 仅集群内 默认,微服务之间互相调用
    NodePort 每台 Node 开一个端口 临时测试、没有云 LB 的环境,生产少用
    LoadBalancer 云厂商分配公网 LB 云上直接对外;每个 Service 一个 LB,成本要注意
    ExternalName 返回 CNAME 把集群内名字指向外部域名

    排障第一招:Service 访问不通,十有八九是 selector 和 Pod 的 labels 对不上,或者 Pod 的 readiness 没通过 → EndpointSlice 是空的。

    4.5 Ingress:一份「规则」,需要有人来执行

    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
    name: order–api
    spec:
    ingressClassName: nginx
    rules:
    – host: order.example.com
    http:
    paths:
    – path: /
    pathType: Prefix
    backend:
    service:
    name: order–api
    port:
    number: 80

    最容易踩的坑:光 kubectl apply 一个 Ingress 对象,什么也不会发生。集群里必须先跑着对应的 Ingress Controller(ingress-nginx、Traefik、APISIX、Cilium 等),由它读取 Ingress 规则并真正接管流量。ingressClassName 也必须和已安装的 Controller 对得上。

    它解决的是「一个公网入口服务多个后端」:

    order.example.com/api → order-api 服务
    order.example.com/admin → admin 服务
    shop.example.com → shop 服务

    2026 年的现状(别学过时了):Kubernetes 官方文档已明确写出「推荐使用 Gateway 而不是 Ingress,Ingress API 已被冻结」——不会被移除,但不会再有新功能;社区里最常用的 ingress-nginx 控制器在 2026 年也走到了维护生命周期尾声。Gateway API 的核心资源(GatewayClass / Gateway / HTTPRoute / GRPCRoute / ReferenceGrant)已是 GA,新集群建议直接上 Gateway API:

    apiVersion: gateway.networking.k8s.io/v1
    kind: HTTPRoute
    metadata:
    name: order–api
    spec:
    parentRefs:
    – name: shared–gateway # 由平台团队创建的 Gateway
    hostnames:
    – order.example.com
    rules:
    – backendRefs:
    – name: order–api
    port: 80

    现实建议:存量集群基本还是 Ingress,必须会看会改;新建集群优先 Gateway API。两者的思路是相通的,学会 Ingress 再迁移并不难。

    4.6 ConfigMap / Secret:把配置从镜像里拿出来

    apiVersion: v1
    kind: ConfigMap
    metadata:
    name: app–config
    data:
    APP_GREETING: "hello from configmap"
    LOG_LEVEL: "INFO"
    —
    apiVersion: v1
    kind: Secret
    metadata:
    name: app–secret
    type: Opaque
    stringData:
    DB_PASSWORD: "demo-pass-123" # 写的时候是明文,API 会转成 base64 存

    两种用法:

    # ① 注入环境变量(适合零散配置项)
    envFrom:
    – configMapRef:
    name: app–config
    – secretRef:
    name: app–secret

    # ② 挂成配置文件(适合 application.yaml、nginx.conf)
    volumeMounts:
    – name: config
    mountPath: /config/application.yaml
    subPath: application.yaml
    readOnly: true

    三个必须知道的实际情况:

  • Secret 不是加密,只是 base64 编码(echo xxx | base64 -d 就能读)。真正的安全靠:etcd 静态加密、RBAC 限制谁能 get secret、外部密钥管理(Vault / 云 KMS / Secrets Store CSI Driver)。
  • 改配置 ≠ 应用立刻生效。环境变量在容器启动时就固定了;卷挂载虽然会同步更新,但用 subPath 挂载的文件不会更新。而且 Spring Boot 默认不热加载配置文件。所以常见做法是改完 ConfigMap 后 kubectl rollout restart deployment/order-api 触发一次滚动重启,或使用支持热加载的配置中心。
  • 「避免了配置变更带来的重新编译」是对的,但说「避免重新部署」不准确——多数情况下仍需重启 Pod。
  • 4.7 Volume:数据持久化其实是一整套对象

    先分清三种东西:

    对象类比说明
    Volume 工位上插着的硬盘 Pod 里声明的挂载点;emptyDir 随 Pod 消失,hostPath 绑死在某台 Node(Pod 漂走就读不到,生产慎用)
    PV(PersistentVolume) 仓库里的一块盘 由管理员或存储插件提供的实际存储资源
    PVC(PersistentVolumeClaim) 领用单 应用说「我要 20Gi、可读写」,K8s 自动找一块合适的 PV 绑定
    StorageClass 自动供货规则 有它就不用手工建 PV,PVC 一提交,云盘自动创建(动态供给)

    # 应用侧只需要写「领用单」
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
    name: data
    spec:
    accessModes: ["ReadWriteOnce"]
    resources:
    requests:
    storage: 20Gi
    # storageClassName 省略即使用集群默认 StorageClass

    kubectl get sc # 看有哪些 StorageClass、哪个是默认
    kubectl get pvc
    kubectl describe pvc data # 卡在 Pending 多半是没默认 SC 或存储配额不足

    关键认知:Pod 重建不会丢 PVC 里的数据,因为盘是独立对象,会被重新挂到新 Pod 上。

    4.8 StatefulSet:给每个副本一个「身份」

    Deployment 的副本是 order-api-7d9f8c6b5-x2k4m 这种随机名,谁替换谁都无所谓。而数据库、消息队列、分布式存储这类应用需要:

    • 稳定的名字:db-0、db-1、db-2(配合 headless Service 得到稳定 DNS);
    • 稳定的磁盘:每个副本绑定自己的 PVC,重建后还是原来那块;
    • 有序启停:按 0→1→2 启动,按 2→1→0 停止。

    apiVersion: v1
    kind: Service
    metadata:
    name: db–headless
    spec:
    clusterIP: None # headless:不做负载均衡,直接返回各 Pod IP
    selector:
    app: db
    ports:
    – port: 5432
    —
    apiVersion: apps/v1
    kind: StatefulSet
    metadata:
    name: db
    spec:
    serviceName: db–headless
    replicas: 3
    selector:
    matchLabels:
    app: db
    template:
    metadata:
    labels:
    app: db
    spec:
    containers:
    – name: db
    image: postgres:16
    volumeMounts:
    – name: data
    mountPath: /var/lib/postgresql/data
    volumeClaimTemplates: # 每个副本自动生成一块独立的 PVC
    – metadata:
    name: data
    spec:
    accessModes: ["ReadWriteOnce"]
    resources:
    requests:
    storage: 20Gi

    上面这段只示意结构,生产跑 PostgreSQL 还得补密码、PGDATA 子目录等配置。 很实在的一句建议:StatefulSet 只解决了「身份 + 磁盘 + 顺序」,没解决主从切换、备份恢复、版本升级、故障转移。生产数据库优先用云托管服务或成熟 Operator(如 CloudNativePG、Zalando Postgres Operator),别拿一个 StatefulSet 硬扛。


    五、清单之外,但生产里一定绕不开的 8 个东西

    #对象一句话不配会怎样
    1 Namespace 集群里的逻辑分组 / 租户隔离 所有资源挤在 default,权限和配额没法管
    2 Label / Selector K8s 的「灵魂」:Service 找 Pod、Deployment 管 Pod、HPA 选目标,全靠标签 标签写错,服务静默地找不到任何 Pod
    3 readinessProbe 「这个 Pod 能接流量了吗」 没配:应用还没启动完就被塞流量,滚动更新时报 502
    4 livenessProbe / startupProbe 卡死了要不要重启 / 慢启动应用别被误杀 liveness 太激进 → 无限重启
    5 resources.requests / limits 申请多少、最多用多少 不写 requests:调度器乱放,节点被撑爆;内存超限 → OOMKilled
    6 HPA 按 CPU / 内存 / 自定义指标自动改副本数 流量高峰全靠人肉 kubectl scale;需要 metrics-server
    7 Job / CronJob 一次性任务 / 定时任务(数据迁移、报表) 用 while(true) 常驻 Pod 跑批,浪费资源又不好重试
    8 ServiceAccount + RBAC Pod 访问 API Server 时是谁、能做什么 默认账号权限过大,或应用要读 ConfigMap 却被拒

    再补三个「进阶但常见」的:DaemonSet(每台 Node 跑一个,日志/监控 agent)、PodDisruptionBudget(滚动维护时保证最少可用副本)、NetworkPolicy(Pod 间网络白名单)。

    Java 应用的一条实战提醒:容器里 -Xmx 别写死小于 limits.memory,也要给堆外(Metaspace、线程栈、DirectBuffer)留余量;JDK 8u191+ / 10+ 支持容器感知,常用 -XX:MaxRAMPercentage=70.0。memory limit 卡到刚好等于堆大小,非常容易被 OOMKilled。


    六、动手:一次可以照着敲的上线

    前提:有一个可用集群;装了 nginx IngressClass;装了 metrics-server(HPA 用)。把镜像换成你自己的,order.example.com 换成可解析的域名,本地练习可用 port-forward 代替 Ingress。

    把下面内容存成 app.yaml:

    apiVersion: v1
    kind: Namespace
    metadata:
    name: demo
    —
    apiVersion: v1
    kind: ConfigMap
    metadata:
    name: app–config
    namespace: demo
    data:
    APP_GREETING: "hello from configmap"
    LOG_LEVEL: "INFO"
    —
    apiVersion: v1
    kind: Secret
    metadata:
    name: app–secret
    namespace: demo
    type: Opaque
    stringData:
    DB_PASSWORD: "demo-pass-123"
    —
    apiVersion: apps/v1
    kind: Deployment
    metadata:
    name: order–api
    namespace: demo
    spec:
    replicas: 3
    selector:
    matchLabels:
    app: order–api
    strategy:
    type: RollingUpdate
    rollingUpdate:
    maxSurge: 1
    maxUnavailable: 0 # 更新过程中始终保持 3 个可用副本
    template:
    metadata:
    labels:
    app: order–api # Service 靠这个标签找到 Pod
    spec:
    containers:
    – name: app
    image: registry.example.com/team/order–api:1.0.0
    ports:
    – containerPort: 8080
    envFrom:
    – configMapRef:
    name: app–config
    – secretRef:
    name: app–secret
    resources:
    requests:
    cpu: 200m
    memory: 256Mi
    limits:
    cpu: "1"
    memory: 512Mi
    readinessProbe: # 决定要不要把流量分给这个 Pod
    httpGet:
    path: /actuator/health/readiness
    port: 8080
    initialDelaySeconds: 10
    periodSeconds: 5
    livenessProbe:
    httpGet:
    path: /actuator/health/liveness
    port: 8080
    initialDelaySeconds: 30
    periodSeconds: 10
    —
    apiVersion: v1
    kind: Service
    metadata:
    name: order–api
    namespace: demo
    spec:
    type: ClusterIP
    selector:
    app: order–api
    ports:
    – name: http
    port: 80
    targetPort: 8080
    —
    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
    name: order–api
    namespace: demo
    spec:
    ingressClassName: nginx
    rules:
    – host: order.example.com
    http:
    paths:
    – path: /
    pathType: Prefix
    backend:
    service:
    name: order–api
    port:
    number: 80
    —
    apiVersion: autoscaling/v2
    kind: HorizontalPodAutoscaler
    metadata:
    name: order–api
    namespace: demo
    spec:
    scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: order–api
    minReplicas: 3
    maxReplicas: 10
    metrics:
    – type: Resource
    resource:
    name: cpu
    target:
    type: Utilization
    averageUtilization: 70

    Spring Boot 3 需暴露 /actuator/health/readiness 与 /liveness(K8s 环境下探针端点默认启用,也可显式配置 management.endpoint.health.probes.enabled=true)。

    6.1 发布与验证

    kubectl apply -f app.yaml
    kubectl get all,ing,cm,secret,hpa -n demo
    kubectl rollout status deployment/order-api -n demo

    # 不依赖域名,本地直接打 Service
    kubectl port-forward -n demo svc/order-api 8080:80
    curl -i http://localhost:8080/actuator/health

    # 看 Pod 里到底注入了什么
    kubectl exec -n demo -it deploy/order-api — env | grep -E 'APP_GREETING|LOG_LEVEL|DB_PASSWORD'

    # 看 Service 到底选中了哪些 Pod
    kubectl get endpointslices -n demo -l kubernetes.io/service-name=order-api -o wide

    6.2 四组实验,比看十遍文档都管用

    实验命令你会看到什么
    ① 自愈 POD=$(kubectl get pod -n demo -l app=order-api -o jsonpath='{.items[0].metadata.name}')kubectl delete pod -n demo "$POD" Deployment 立刻补一个新 Pod,Service 的 EndpointSlice 自动更新
    ② 扩容 kubectl scale deployment/order-api -n demo –replicas=5 新 Pod 就绪后被自动加入 Service 后端,不用改任何 Service 配置
    ③ 更新与回滚 kubectl set image deployment/order-api app=…:1.0.1 -n demokubectl rollout status …kubectl rollout undo … 逐个替换、始终有可用副本;一条命令回滚
    ④ 配置不生效 kubectl edit cm app-config -n demo 改掉 APP_GREETING,再 exec 进去看 环境变量还是旧值 → kubectl rollout restart deployment/order-api -n demo 后才生效

    第 ④ 组是新手最容易懵的地方,也是「ConfigMap 不是热更新」这件事最直观的证据。


    七、出问题时,按这个顺序看

    症状先看哪儿命令
    Pod 一直 Pending 资源不够 / 没节点满足亲和性 / PVC 没绑定 kubectl describe pod <pod> -n demo(看 Events)
    CrashLoopBackOff 启动即失败、配置缺失、liveness 太激进 kubectl logs <pod> -n demo –previous
    ImagePullBackOff 镜像名错、私有仓库没配 imagePullSecrets kubectl describe pod
    Service 访问不通 selector 与 labels 不一致、readiness 没过、端口写错 kubectl get endpointslices -n demo -l kubernetes.io/service-name=order-api
    Ingress 404 / 无地址 没装 Controller、ingressClassName 不匹配、host/path 不对 kubectl describe ing order-api -n demo
    滚动更新卡住 新 Pod readiness 不过,而 maxUnavailable=0 kubectl rollout status + kubectl describe pod
    配置改了没生效 环境变量固定 / subPath 不更新 kubectl rollout restart deployment/order-api -n demo
    Pod 被反复杀掉 内存超 limits kubectl describe pod(看 OOMKilled、Exit Code 137)
    HPA 显示 <unknown> 没装 metrics-server,或没配 requests kubectl get hpa -n demo、kubectl top pod -n demo

    通用套路:get 看状态 → describe 看 Events → logs 看应用 → exec 进去验证环境 → get events –sort-by=.lastTimestamp 看集群层面发生了什么。

    kubectl get events -n demo –sort-by=.lastTimestamp | tail -20


    八、什么时候其实不该上 K8s

    不脱离实际地说,K8s 不总是答案:

    场景更合适的选择
    一个单体应用 + 一个数据库,日活几百 一台云主机 + Docker Compose / systemd,省下的运维精力远大于收益
    团队里没人负责集群升级、证书、网络插件、备份 云厂商托管容器服务(ACK / TKE / EKS)或 Serverless 容器,别自建控制面
    没有弹性扩缩、多副本、灰度发布的需求 用不上调度与调谐循环,复杂度纯属负担
    核心数据库要上生产 优先云托管数据库或成熟 Operator,而不是手写 StatefulSet
    只是想跑个定时任务 CronJob 可以,但一个云函数 / 定时任务服务更省事

    判断标准很简单:你是否需要「多副本 + 自愈 + 滚动发布 + 弹性 + 统一资源编排」中的至少两三项,并且有团队承担平台成本。需要,K8s 才划算。



    小结

    把开头的清单换成一条主线,K8s 就没那么难了:

    你提交一份「期望状态」(YAML)
    → Deployment 保证 3 个 Pod 一直活着
    → Pod 从 ConfigMap/Secret 拿配置、从 PVC 拿磁盘
    → Service 用标签找到这些 Pod,给出稳定入口
    → Ingress(或现在的 Gateway API)把外部域名请求引到 Service
    → HPA 按负载改副本数
    → 所有 Controller 在后台不停调谐,把实际状态拉回期望状态

    组件不是要背的名词,是一个个被具体麻烦逼出来的解法。当你能解释「为什么 Pod 重建后调用方不受影响」「为什么改了 ConfigMap 应用没反应」「为什么写了 Ingress 却访问不通」,这套东西就算真的理解了。


    参考

    • Kubernetes 官方文档:Concepts(Workloads / Services, Networking / Storage / Configuration)
    • Kubernetes 官方文档:Ingress Controllers(关于 Ingress API 冻结与推荐 Gateway API 的说明)
    • Kubernetes Releases 页面(版本支持周期)
    • Gateway API 官方文档(Gateway / HTTPRoute / ReferenceGrant)

    本文示例基于 Kubernetes 1.35+ 通用 API 与 Spring Boot 3.x;networking.k8s.io/v1、apps/v1、autoscaling/v2 在近几个版本均稳定。生产使用前请把镜像、域名、资源配额与探针路径替换为自己的真实值。

    赞(0)
    未经允许不得转载:网硕互联帮助中心 » 别再背组件名词了:跟着「一次上线」把 K8s 讲明白
    分享到: 更多 (0)

    评论 抢沙发

    评论前必须登录!