Kind:从零搭一个多节点 Kubernetes 集群

Clúster Kubernetes multi-nodo con Kind
Sesión 4 · Bloque II — Contenedores y Orquestación
怎么用这份讲义

一、从 docker run 到编排器

p.1–p.4
p.1

Inicialización del clúster Kubernetes multi-nodo con Kind · 用 Kind 初始化多节点 Kubernetes 集群

▸ 原页截图 p.1 原讲义第 1 页

BLOQUE II — CONTENEDORES Y ORQUESTACIÓN

第二篇——容器与编排

Inicialización del clúster Kubernetes multi-nodo con Kind

用 Kind 初始化多节点 Kubernetes 集群

Duración: 2 horas — teoría con tareas cortas intercaladas

时长:2 小时——理论讲解中穿插短任务。

4

4

记忆钩子:封面上的 4 是本课序号(Sesión 4),不是 PDF 页码(PDF 第 1 页)。页脚/页眉里的 «Sesión 4 — Clúster Kubernetes multi-nodo con Kind» 同理,是课程标题不是章节号。
考点:这节课的关键词只有三个——orquestador(谁来管)、bucle de reconciliación(怎么管)、Kind(在哪练)。后面的 27 页都是这三件事的展开。
p.2

Objetivos de esta sesión · 本节课目标

▸ 原页截图 p.2 原讲义第 2 页

Objetivos de esta sesión

本节课目标

3 min

3 分钟

Hasta ahora habéis manejado contenedores de uno en uno, a mano, sobre una sola máquina.

到现在为止,你们都是在一台机器上、手工地、一个接一个地管理容器。

Hoy dais el salto: quién los arranca por vosotros, quién decide dónde, y quién los vuelve a levantar cuando se caen.

今天你们要跨一步:谁来替你们启动它们、谁来决定放在哪、以及它们挂掉时谁来重新拉起。

• Qué problema resuelve un orquestador, y por qué "docker run" no escala

• 编排器解决什么问题,以及为什么「docker run」无法扩展

• La arquitectura de Kubernetes: plano de control frente a plano de datos

• Kubernetes 架构:控制平面对数据平面

• El bucle de reconciliación: la idea que explica todo lo demás

• 调和循环:一个能解释其余一切的概念

• Qué es Kind y por qué nos sirve un clúster hecho de contenedores

• Kind 是什么,以及为什么「用容器搭出来的集群」对我们够用

• Levantar y explorar vuestro propio clúster de 3 nodos

• 启动并探索你们自己的 3 节点集群

A partir de hoy: este clúster es vuestro entorno de trabajo hasta el final de la asignatura.

从今天起:这个集群就是你们的工作环境,直到本课程结束。

Cuidadlo.

爱惜它。

这页就是全课路线图:为什么(问题)→ 是什么(架构 + 对象)→ 怎么跑(Kind + kubectl)→ 怎么用(部署、诊断)。后面每节都能挂到这五条上。
记忆钩子:「谁启动、谁决定位置、谁重新拉起」——三个「谁」就是编排器的三件职责。
p.3

El problema que aparece al crecer · 规模变大后暴露的问题

▸ 原页截图 p.3 原讲义第 3 页

Por qué "docker run" deja de servir

为什么「docker run」不再够用

Con tres contenedores en un portátil, Docker basta.

笔记本上跑三个容器,Docker 足够。

El problema no es técnico, es de escala y de operación: alguien tiene que hacer estas cosas, y ese alguien no puede ser una persona mirando una terminal.

问题不是技术性的,而是规模和运维性质的:这些事总得有人做,而这个人不能是一个盯着终端的人。

PreguntaCon Docker a manoLo que hace falta
Un contenedor se cae de madrugadaNadie lo levantaReinicio automático
Necesito 10 réplicas, no 110 comandos, y recordarlosDeclarar "quiero 10"
La máquina se queda sin RAMFalla y ya estáReprogramar en otra máquina
Quiero actualizar sin cortar servicioA mano, con cuidadoDespliegue progresivo
¿A qué IP llamo, si cambian?Mirarlo cada vezNombre estable + balanceo

La respuesta común: un orquestador: un sistema al que le describís el estado deseado y que se encarga permanentemente de que la realidad se le parezca.

共同的答案是:一个编排器——你们向它描述期望状态,它则持续负责让现实向这个状态靠拢。

考点:五个场景对应编排器的五种能力——自愈、副本数、重调度、滚动更新、稳定名称 + 负载均衡。问 «¿Por qué no basta docker run?» 就按这五条答。
注意原文的双冒号 «La respuesta común: un orquestador: …» 是口语式停顿,不是笔误;中文用破折号处理最顺。
p.4

La idea central: declarativo, no imperativo · 核心思想:声明式而非命令式

▸ 原页截图 p.4 原讲义第 4 页

Si entendéis esto, el resto de Kubernetes se deduce

只要理解这一点,Kubernetes 其余部分都能推导出来

Imperativo (Docker)

命令式(Docker)

Dais ÓRDENES: "arranca este contenedor".

你们下的是命令:「启动这个容器」。

Si luego se muere, el sistema no hace nada: la orden ya se ejecutó en su momento.

如果它随后死了,系统什么也不做:命令在当初就已经执行完了。

Declarativo (Kubernetes)

声明式(Kubernetes)

Declaráis un ESTADO: "quiero 3 réplicas de esto".

你们声明的是一个状态:「我要 3 个这东西的副本」。

Si una se muere, la realidad deja de coincidir con lo declarado, y el sistema actúa.

如果其中一个死了,现实就与所声明的不再一致,系统于是采取行动。

Kubernetes ejecuta permanentemente el mismo bucle sobre cada objeto que le habéis declarado:

Kubernetes 会对你们声明过的每个对象,持续执行同一个循环:

Observar — Estado real

观察——真实状态

Comparar — Real vs deseado

比较——现实对期望

Actuar — Corregir la diferencia

行动——修正差异

Nombre técnico: bucle de reconciliación (reconciliation loop).

技术名称:调和循环(reconciliation loop)。

Cada controlador de Kubernetes es una instancia de esto.

Kubernetes 的每一个控制器都是这个循环的一个实例。

考点(必背):命令式 = 执行一次就结束;声明式 = 永远在把现实拉回声明。被问 «¿Qué pasa si borro un Pod?» 答:ReplicaSet 的调和循环会发现少了副本并重建——这正是声明式的证据。
记忆钩子:观察 → 比较 → 行动,三个动词背下来,Deployment、Service、Node 的控制器全是同一套。

二、Kubernetes 架构与对象

p.5–p.8
p.5

Arquitectura: dos planos · 架构:两个平面

▸ 原页截图 p.5 原讲义第 5 页

Quién decide y quién ejecuta

谁做决定,谁去执行

PLANO DE CONTROL (decide)

控制平面(做决定)

• kube-apiserver — la única puerta de entrada

• kube-apiserver——唯一的入口大门

• etcd — almacén del estado declarado

• etcd——存放已声明状态的仓库

• kube-scheduler — elige nodo para cada Pod

• kube-scheduler——为每个 Pod 挑选节点

• kube-controller-manager — los bucles

• kube-controller-manager——那些循环

PLANO DE DATOS (ejecuta)

数据平面(执行)

• kubelet — agente en cada nodo

• kubelet——每个节点上的代理

• containerd — motor de contenedores

• containerd——容器运行时

• kube-proxy — reglas de red de Services

• kube-proxy——Service 的网络规则

• CNI — conectividad entre Pods

• CNI——Pod 之间的连通性

Regla de oro: nada habla con etcd directamente salvo el apiserver.

黄金法则:除了 apiserver,没有任何组件直接跟 etcd 说话。

Todo lo demás — kubectl, los controladores, el kubelet — pasa por la API.

其他一切——kubectl、各个控制器、kubelet——都要经过 API。

Eso es lo que hace que RBAC (Sesión 7) pueda controlarlo todo desde un solo sitio.

正因如此,RBAC(第 7 讲)才能在一个地方控制全部。

Ojo con la terminología: antes se decía "máster" y "minion".

注意术语:以前叫「máster」和「minion」。

Hoy son "control plane" y "worker node".

如今是「控制平面」和「工作节点」。

Encontraréis ambos en la documentación antigua.

在旧文档里两种说法都会遇到。

考点:控制平面做决定,数据平面做执行;四个控制组件、四个节点组件必须能对号入座。特别注意 scheduler 只选节点、不启动容器。
易错:etcd 只在控制平面;kube-proxy 通过 API 读 Service/Endpoint,不直接读 etcd——「唯一客户是 apiserver」正是这句 «Regla de oro» 的意思。
p.6

Los componentes, uno a uno · 逐个认识组件

▸ 原页截图 p.6 原讲义第 6 页

Qué hace exactamente cada proceso

每个进程到底做什么

ComponenteDóndeResponsabilidad
kube-apiserverControl planeRecibe, valida y autoriza toda petición. Es una API REST sobre HTTPS.
etcdControl planeBase de datos clave-valor distribuida. Guarda el estado declarado. Si se pierde, se pierde el clúster.
kube-schedulerControl planeVe Pods sin nodo asignado y elige uno según recursos, afinidades y restricciones.
controller-managerControl planeEjecuta los bucles de reconciliación (Deployment, ReplicaSet, Node, Endpoint...).
kubeletCada nodoRecibe la lista de Pods que le tocan y se asegura de que sus contenedores corran.
kube-proxyCada nodoPrograma las reglas que hacen funcionar los Service. Volverá en la Sesión 7.

Fijaos: el scheduler solo ELIGE nodo; no arranca nada.

注意:调度器只「选」节点,它不启动任何东西。

Quien arranca es el kubelet del nodo elegido.

真正启动容器的是被选中节点上的 kubelet。

Separar decisión y ejecución es lo que permite escalar.

把「决定」和「执行」分开,正是能够扩展的原因。

考点:六个组件按「控制平面 / 每个节点」二分。etcd 丢了 = 集群丢了;apiserver 是 REST over HTTPS;scheduler 只挑选、kubelet 才落地——三句话年年考。
记忆钩子:控制平面四个 api / etcd / scheduler / controller-manager;节点上三个 kubelet / containerd / kube-proxy,再加一个 CNI 插件。
p.7

Tarea — antes de instalar nada — leed la API · 任务:装任何东西之前,先读 API

▸ 原页截图 p.7 原讲义第 7 页

kubectl trae la documentación de la API incorporada.

kubectl 自带一份内建的 API 文档。

Es la referencia más fiable que vais a tener: describe exactamente la versión que corre en vuestro clúster, no una genérica de Internet.

这是你们能拿到的最可靠的参考:它描述的正是你们集群里运行的那个版本,而不是网上某个通用版本。

Recordad esto: "kubectl explain" es vuestro manual de referencia offline.

记住这一点:「kubectl explain」就是你们的离线参考手册。

En el examen práctico estará disponible.

实操考试中它是可用的。

终端 · 出处:Sesión 4 · p.7

$ kubectl explain pod.spec.containers
$ kubectl explain deployment.spec --recursive
命令 / 参数逐行说明
kubectl explain查字段文档。不联网,读的是本集群 apiserver 里的 OpenAPI,所以版本永远对得上。
pod.spec.containers点号就是路径:资源类型 → 顶层字段 → 子字段,一层层往下钻。
deployment.spec资源名写小写、单数(deploy 这类缩写也认);换成 svc、ing 一样能查。
--recursive递归打印整棵字段树,一次看清嵌套结构;不加只显示当前这一层。
$提示符,不用输入;它表示后面这行在普通用户终端里执行。
这段在考什么:记不住 YAML 字段时用 explain,比搜索引擎快且不会过时——它描述的是你们集群里正在跑的那个版本。
考点:为什么 explain 比网上文档可靠?因为它读的是本集群的 API 版本(CRD 也能解释),而网上文档可能对应别的版本。
p.8

Los objetos que vais a manejar · 你们将要操作的对象

▸ 原页截图 p.8 原讲义第 8 页

De menor a mayor

由小到大

Contenedor — Un proceso aislado. Lo de la Sesión 1.

容器——一个被隔离的进程。第 1 讲的内容。

Pod — Unidad mínima. 1 o varios contenedores que comparten IP y almacenamiento.

Pod——最小单位。一个或几个共享 IP 与存储的容器。

ReplicaSet — Mantiene N copias de un Pod vivas.

ReplicaSet——维持 N 个 Pod 副本存活。

Deployment — Gestiona ReplicaSets para actualizar sin cortar servicio.

Deployment——管理 ReplicaSet,从而不中断服务地更新。

Clave para la red: la IP se asigna al POD, no al contenedor.

网络上的关键点:IP 分配给的是 POD,不是容器。

Dos contenedores del mismo Pod comparten IP y se hablan por localhost — es el patrón que Istio usará en la Sesión 11 para meter su proxy.

同一个 Pod 的两个容器共享 IP,通过 localhost 通信——第 11 讲 Istio 就是利用这个模式塞进它的代理。

En la práctica: casi nunca crearéis un Pod suelto: crearéis un Deployment, que crea un ReplicaSet, que crea los Pods.

实践上:几乎不会去创建一个孤零零的 Pod——你们创建 Deployment,它创建 ReplicaSet,ReplicaSet 再创建 Pod。

Si borráis un Pod a mano, el ReplicaSet lo vuelve a crear — eso no es un fallo, es el bucle de reconciliación funcionando.

如果你手动删掉一个 Pod,ReplicaSet 会再建一个——这不是故障,而是调和循环在工作。

考点:Deployment → ReplicaSet → Pod 的层级必须能画出来;IP 属于 Pod 是第 5、6 讲网络部分的起点,也是问 «¿Dos contenedores del mismo Pod cómo se comunican?» 的标准答案(localhost)。
记忆钩子:删 Pod 会自动长回来——不是 bug,是「声明 3 个就永远给你 3 个」。

三、Kind:用容器搭一个真集群

p.9–p.12
p.9

¿Cómo se instala Kubernetes? · Kubernetes 怎么装

▸ 原页截图 p.9 原讲义第 9 页

¿Cómo se instala Kubernetes?

Kubernetes 怎么安装?

Y por qué en este curso usamos Kind

以及为什么本课程用 Kind

OpciónQué esEncaje en el curso
kubeadmLa herramienta oficial para montar un clúster real sobre máquinas.Realista, pero exige varias VM: poco viable según el portátil.
Funciona también en una sola, pero se apodera de ella (instala kubelet como servicio, escribe en /etc/kubernetes) y para tener varios nodos exige varias VM.
minikubeUn clúster de un solo nodo para desarrollo.Entorno de desarrollo local. Admite varios nodos (--nodes <N>), pero es más pesado y mete un controlador de por medio (una VM o un contenedor según la plataforma).
KindKubernetes IN Docker: cada nodo del clúster es un contenedor Docker.Multi-nodo real, ligero y reproducible. Es el que usaremos.
k3sDistribución ligera certificada, pensada para el borde y IoT.Buena alternativa, pero cambia componentes que queremos ver tal cual.
EKS / GKE / AKSKubernetes gestionado por un proveedor cloud.Requiere cuenta y tarjeta. Lo veremos como concepto en la Sesión 15.

La idea de Kind, en una frase: lo que en un clúster real es una máquina, aquí es un contenedor Docker que por dentro ejecuta containerd y kubelet.

用一句话概括 Kind 的思路:真实集群里的一台机器,在这里就是一个 Docker 容器,容器内部跑着 containerd 和 kubelet。

Sí: contenedores dentro de un contenedor.

没错:容器里的容器。

Por eso Kind necesita que Docker funcione, y por eso todo lo aprendido en las Sesiones 1-3 sigue aplicando.

所以 Kind 要求 Docker 能正常工作,也所以第 1–3 讲学到的东西全部继续适用。

考点:四种方案对比必记——kubeadm 官方但吃机器/要多台 VM;minikube 单节点、较重;Kind 每节点一个容器、多节点轻量可复现;k3s 轻量但换组件。问 «¿Por qué Kind?» 答:multi-nodo real, ligero y reproducible。
记忆钩子:Kind = Kubernetes IN Docker,名字本身就是定义。
p.10

Declarar el clúster: kind-cluster.yaml · 声明集群

▸ 原页截图 p.10 原讲义第 10 页

También aquí se declara, no se ordena

这里同样是「声明」,不是「下命令」

Tres nodos:

三个节点:

Uno de control, que aloja apiserver, etcd, scheduler y controller-manager.

一个控制节点,承载 apiserver、etcd、scheduler 和 controller-manager。

Dos workers, donde se ejecutarán vuestras aplicaciones.

两个 worker,你们的应用将运行在那里。

Dos workers es el mínimo para poder estudiar el tráfico ENTRE nodos, que es el objetivo de la Sesión 6.

两个 worker 是研究「节点之间」流量的最低配置,而这正是第 6 讲的目标。

kind-cluster.yaml · 出处:Sesión 4 · p.10

# kind-cluster.yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: redes-virtualizadas
nodes:
  - role: control-plane
  - role: worker
  - role: worker
配置项逐行说明
kind: Cluster对象类型:这是 kind 的集群配置,不是 K8s 里的某个资源。
apiVersion: kind.x-k8s.io/v1alpha4kind 自己的配置版本,与 K8s 资源的 apiVersion 无关;照着写 v1alpha4。
name: redes-virtualizadas集群名;之后 kubeconfig 里的 context 就叫 kind-redes-virtualizadas。
nodes:节点清单,每一项对应一个 Docker 容器。
- role: control-plane / workerrole 只有这两种身份:1 个控制面 + 2 个 worker。
这段在考什么:kind 的配置文件本身就是声明式的——你只写「我要 1 个 control-plane + 2 个 worker」,不写任何创建步骤。三个 role 就是三个容器节点的身份。

创建命令 · 出处:Sesión 4 · p.10

kind create cluster --name NOMBRE --config FICHERO.yaml
命令逐行说明
kind create cluster建集群子命令;kind 建的「节点」其实是 Docker 容器。
--name NOMBRE集群名,同时决定 kubeconfig 的 context 名与容器名前缀。
--config FICHERO.yaml指定节点清单文件;省略就只建一个单节点集群。
这段在考什么:--name 给集群起名(同时决定 kubeconfig 里的 context 名和 docker ps 里的容器前缀);--config 指向刚才那份声明文件。漏掉 --config 就只会建一个单节点集群,三个 role 全部失效。

La primera vez descarga la imagen kindest/node (varios cientos de MB) y tarda unos minutos.

第一次会下载 kindest/node 镜像(几百 MB),要花几分钟。

Después es rápido.

之后就很快了。

Antes de empezar: cerrad lo que no necesitéis: el clúster va a pedir memoria de verdad.

开始之前:把不需要的程序关掉——这个集群是真的要吃内存。

易错:kind create cluster 的 --config 必须指向文件;--name 不写时默认叫 kind,后续 kind delete cluster 要带同一个名字,否则删不掉你以为的那个集群。
考点:role 只有两种值——control-plane 与 worker;本课配置必须能默写(1 控制 + 2 工作)。
p.11

Tarea — cread vuestro clúster · 任务:创建你们的集群

▸ 原页截图 p.11 原讲义第 11 页

Escribid el fichero y lanzad la creación.

写好文件,然后启动创建。

Mientras descarga, leed la salida: va nombrando cada fase de lo que hemos explicado.

下载的时候读一读输出:它会把我们讲过的每个阶段一一命名。

Mientras espera: fijaos en el paso "Installing CNI": ahí se instala el plugin de red.

等待时注意 «Installing CNI» 这一步:网络插件就是在这里装上的。

Lo cambiaremos en la Sesión 7.

第 7 讲我们会把它换掉。

终端实录 · 出处:Sesión 4 · p.11

$ mkdir -p ~/rsv && cd ~/rsv
$ nano kind-cluster.yaml          # copiad el YAML de la slide anterior

$ kind create cluster --name redes-virtualizadas --config kind-cluster.yaml
  - Ensuring node image (kindest/node:v1.xx.x)
  - Preparing nodes
  - Writing configuration
  - Starting control-plane
  - Installing CNI
  - Installing StorageClass
  - Joining worker nodes
Set kubectl context to "kind-redes-virtualizadas"
命令逐行说明
mkdir -p ~/rsv-p:目录已存在也不报错;建立工作目录。
cd ~/rsv进入工作目录,后面的相对路径都以它为准。
nano kind-cluster.yaml用编辑器把 p.10 的 YAML 粘进去并保存。
kind create cluster --name ... --config ...按文件建集群;--name 与文件里的 name 保持一致,context 才是 kind-redes-virtualizadas。
- Ensuring node image … - Joining worker nodes每个缩进行是一个阶段,顺序见下方「这段在考什么」。
这段在考什么:输出的顺序就是集群搭建的真实顺序——准备节点 → 写配置 → 起控制面 → 装 CNI → 装 StorageClass → 加入 worker。考试问「CNI 什么时候装」答:控制面起来之后、worker 加入之前。
考点:Installing CNI 是唯一与网络直接相关的一步;Set kubectl context to "kind-redes-virtualizadas" 说明 kind 自动帮你写好了 kubeconfig(下页主题)。
p.12

Anidamiento en despliegues Kind · Kind 部署中的嵌套

▸ 原页截图 p.12 原讲义第 12 页

En Kind, los nodos se despliegan como contenedores, no como máquinas virtuales.

在 Kind 里,节点是以容器形式部署的,不是虚拟机。

Anidamiento · 出处:Sesión 4 · p.12

Windows
 └─ VM de VirtualBox          rsv01                  192.168.56.121
     └─ contenedor-nodo       cluster01-control-plane  172.18.0.x
         └─ contenedor del Pod                          10.244.x.x
图中的层逐行说明
Windows宿主机,VirtualBox 跑在这里。
VM de VirtualBox · 192.168.56.121第一层:Host-Only 网段的虚拟机 rsv01。
contenedor-nodo · 172.18.0.x第二层:kind 的节点容器,走 Docker bridge 网段。
contenedor del Pod · 10.244.x.x第三层:Pod,走 CNI 网段。
读图要点:三层地址、三个网段——宿主机/VM 的 192.168.56.x(VirtualBox Host-Only)、节点容器的 172.18.0.x(kind 的 bridge 网络,等价于第 3 讲的 docker0)、Pod 的 10.244.x.x(CNI 网段)。每一层都是一次 NAT/转发。
考点:问 «¿Un nodo de Kind es una VM?» 答:No, es un contenedor Docker;所以它才有 172.18.0.x 这种 bridge 地址,而不是 VirtualBox 的 192.168.56.x。
记忆钩子:VM 里套容器,容器里再套 Pod——「俄罗斯套娃」,一共三层网络。

四、连上集群:kubeconfig 与 kubectl

p.13–p.15
p.13

¿Cómo sabe kubectl a qué clúster hablar? · kubectl 怎么知道跟哪个集群说话

▸ 原页截图 p.13 原讲义第 13 页

El fichero kubeconfig y los contextos

kubeconfig 文件与上下文

kubectl no tiene ninguna configuración mágica: lee ~/.kube/config, un fichero YAML con tres listas — clústeres (dónde está la API), usuarios (con qué credenciales) y contextos (qué usuario contra qué clúster).

kubectl 没有什么魔法配置:它读的是 ~/.kube/config,一个含三个列表的 YAML 文件——集群(API 在哪)、用户(用什么凭证)、上下文(哪个用户对哪个集群)。

~/.kube/config(节选)· 出处:Sesión 4 · p.13

clusters:
- name: kind-redes-virtualizadas
  cluster: { server: https://127.0.0.1:39421, certificate-authority-data: LS0t... }
users:
- name: kind-redes-virtualizadas
  user: { client-certificate-data: LS0t..., client-key-data: LS0t... }
contexts:
- name: kind-redes-virtualizadas
  context: { cluster: kind-redes-virtualizadas, user: kind-redes-virtualizadas }
current-context: kind-redes-virtualizadas
字段逐行说明
clusters:集群条目:server 地址 + certificate-authority-data(CA 证书,base64)。
users:身份条目:client-certificate-data + client-key-data(客户端证书与私钥,base64)。
contexts:用名字把 cluster 和 user 绑成一条上下文。
current-context:默认使用哪一条上下文。
server: https://127.0.0.1:39421本机高位端口,由 Docker 转发到控制面容器;集群重建后端口可能变化。
LS0t...证书内容的 base64 开头,不是真的省略号。
这段在考什么:三张表靠名字互相引用——context 把 cluster 和 user 粘在一起,current-context 决定「现在用哪一对」。kubectl config use-context 改的就是最后这一行。

Fijaos en el server: apunta a 127.0.0.1 y a un puerto alto.

注意 server:它指向 127.0.0.1,而且是一个高位端口。

Es un puerto publicado por Docker: el DNAT de la Sesión 3, otra vez. (se puede consultar también con docker ps)

这是 Docker 发布出来的端口:第 3 讲的 DNAT 又出现了。(也可以用 docker ps 查。)

Seguridad: ese fichero contiene un certificado de administrador del clúster.

安全提醒:这个文件里含有集群管理员证书。

Tratadlo como una contraseña: no se sube a Git ni se comparte.

把它当密码对待:不要提交到 Git,也不要分享。

考点:kubeconfig 三段式——clusters / users / contexts;127.0.0.1 高位端口 = Docker 端口映射,不是 apiserver 真监听在宿主机上。安全题必答:它是管理员凭证,等同密码。
p.14

kubectl: la gramática · kubectl 的语法

▸ 原页截图 p.14 原讲义第 14 页

Un patrón que se repite siempre

一个永远重复的模式

kubectl ACCION ÁMBITO [NOMBRE] [-n NAMESPACE] [-o FORMATO] [FLAGS]

kubectl 动作 范围 [名字] [-n 命名空间] [-o 格式] [其他标志]

Casi todo lo que haréis en el curso encaja en esta plantilla.

本课程中你们要做的几乎所有事,都能套进这个模板。

ParteValores frecuentes
ACCIONget, describe, create, apply, delete, logs, exec, edit, explain
ÁMBITOpod (po), deployment (deploy), service (svc), node (no), namespace (ns)
-o FORMATOwide (más columnas), yaml, json, jsonpath=..., name
Selectores-l app=web (por etiqueta), --all-namespaces / -A
Seguimiento-w (watch, se queda mirando cambios en vivo)

Truco que os ahorrará horas: la VM ya trae el autocompletado y el alias k.

能给你们省下几个小时的技巧:虚拟机已经自带自动补全和别名 k。

Comprueba: escribe k get po y pulsa Tab; y k -n kube-system get pod + Tab te lista los Pods que existen de verdad.

验证一下:输入 k get po 按 Tab;再输入 k -n kube-system get pod + Tab,它会列出真实存在的 Pod。

Para ponerlo en otra máquina hacen falta tres líneas en ~/.bashrc:

要在别的机器上也启用,需要在 ~/.bashrc 里加三行:

~/.bashrc · 出处:Sesión 4 · p.14

source <(kubectl completion bash)
alias k=kubectl
complete -o default -F __start_kubectl k
命令逐行说明
source <(kubectl completion bash)把 kubectl 生成的补全脚本加载进当前 shell;<(...) 是进程替换。
alias k=kubectl起短别名,之后 k get pods 等价于 kubectl get pods。
complete -o default -F __start_kubectl k-F 指定补全函数;-o default 允许回退到默认补全;末尾的 k 是绑定对象。
这段在考什么:第三行是关键——只写 alias 不改补全函数,按 Tab 补的是 kubectl 的命令而不是 k 的;complete ... k 把补全绑到别名上。
考点:语法顺序 动作 → 范围 → 名字 → 标志;-o wide 多列(含 IP/节点)、-o yaml 导出、-l 按标签选、-A 全命名空间、-w 持续观察——这五个标志必须条件反射。
p.15

Tarea — explorad el clúster que acabáis de crear · 任务:探索刚建好的集群

▸ 原页截图 p.15 原讲义第 15 页

Comprobad los tres nodos, sus direcciones y qué papel tiene cada uno.

检查三个节点、它们的地址,以及各自扮演的角色。

Anotad: las tres IP internas y la subred a la que pertenecen.

记录:三个内部 IP,以及它们所属的子网。

Comparadla con la de docker0 de la Sesión 3.

把它和第 3 讲里 docker0 的网段做比较。

终端实录 · 出处:Sesión 4 · p.15

$ kubectl cluster-info
$ kubectl get nodes -o wide
NAME                                    STATUS   ROLES           INTERNAL-IP
redes-virtualizadas-control-plane       Ready    control-plane   172.18.0.4
redes-virtualizadas-worker              Ready    <none>          172.18.0.2
redes-virtualizadas-worker2             Ready    <none>          172.18.0.3

$ kubectl get pods -A            # la infraestructura interna
$ kubectl describe node redes-virtualizadas-worker | head -40
命令逐行说明
cluster-info控制面地址(以及 CoreDNS 是否在跑)。
get nodes -o wide-o wide 增加 INTERNAL-IP、OS、内核等列。
get pods -A-A = --all-namespaces,列出所有命名空间的 Pod。
describe node ... | head -40head -40 只取前 40 行,避免刷屏。
这段在考什么:三个节点都在 172.18.0.0/16(kind 的 bridge 网络)里,宿主机上的 docker0 通常是 172.17.0.0/16——同为 Docker bridge,只是网段不同。ROLES 列 <none> 说明 worker 没有特殊角色标签,不是故障。
考点:kubectl get nodes -o wide 是查看节点 IP 与角色的标准命令;控制节点名字里带 control-plane,两个 worker 带 worker。考试若问「节点 IP 属于哪个网段」,答案要看 kind 网络的 172.18.0.0/16。
记忆钩子:-o wide = 多两列(IP + 节点),看拓扑就靠它。

五、进入集群:节点、命名空间与调度

p.16–p.20
p.16

La comprobación que lo une todo · 把一切串起来的验证

▸ 原页截图 p.16 原讲义第 16 页

Vuestros "nodos" son contenedores Docker

你们的「节点」是 Docker 容器

Kubernetes cree que tiene tres máquinas.

Kubernetes 以为自己有三台机器。

Docker sabe que son tres contenedores.

Docker 知道它们是三个容器。

Las dos cosas son ciertas a la vez, y verlo desde los dos lados es el objetivo de esta parte.

两件事同时为真,而从两个视角都看一遍,就是这一部分的目的。

Conclusión que os interesa: Kind crea una red bridge de usuario llamada "kind" — exactamente el tipo de red que creasteis vosotros en la Sesión 3.

你们该记住的结论:Kind 会创建一张名为 «kind» 的用户网桥网络——正是你们在第 3 讲亲手创建过的那种网络。

La red entre nodos es, literalmente, lo que ya sabéis.

节点之间的网络,字面上就是你们已经会的东西。

Y por tanto: podéis capturar el tráfico entre nodos con tcpdump en la interfaz br-* de esa red.

因此:你们可以在这张网络的 br-* 接口上用 tcpdump 抓节点之间的流量。

Lo haréis en la Sesión 6.

第 6 讲你们就会这么做。

考点:Kind 的节点网络 = 用户自定义 bridge(名为 kind),不是 overlay、不是 macvlan;因此它和 docker0 是同类,只换了个网段和名字。抓包位置:宿主机上的 br-<id>。
记忆钩子:Kubernetes 看是机器,Docker 看是容器——同一个东西的两副面孔;第三副面孔是「一张 Linux bridge」。
p.17

Tarea — entrad dentro de un nodo · 任务:进入一个节点内部

▸ 原页截图 p.17 原讲义第 17 页

Si un nodo es un contenedor, se puede entrar en él.

既然节点是一个容器,就能进到它里面。

Dentro encontraréis los procesos de Kubernetes que hemos descrito en la teoría.

在里面你们会看到理论部分描述过的那些 Kubernetes 进程。

Lo que acabáis de descubrir: el propio plano de control corre como Pods.

你们刚刚发现的是:控制平面本身就以 Pod 形式运行。

Los define el kubelet leyendo esos ficheros: se llaman "static pods".

它们由 kubelet 读取这些文件来定义:叫做「静态 Pod」。

终端实录 · 出处:Sesión 4 · p.17

$ docker exec -it redes-virtualizadas-control-plane bash

root@control-plane:/# ps aux | grep -E "kubelet|apiserver|etcd|scheduler"
root@control-plane:/# crictl ps            # el "docker ps" de containerd
root@control-plane:/# ls /etc/kubernetes/manifests/
etcd.yaml  kube-apiserver.yaml  kube-controller-manager.yaml  kube-scheduler.yaml
root@control-plane:/# exit
命令逐行说明
docker exec -it ... bash-i 保持 stdin,-t 分配终端;在节点容器里开交互 shell。
ps aux | grep -E "kubelet|apiserver|etcd|scheduler"-E 用扩展正则,一次筛四个进程。
crictl pscontainerd 的容器列表;节点里没有 Docker CLI,所以用 crictl。
ls /etc/kubernetes/manifests/查看 static pod 的四个清单文件。
exit退出容器 shell,回到宿主机。
这段在考什么:/etc/kubernetes/manifests/ 下的四个 YAML 就是控制平面的四个组件;kubelet 监视这个目录,文件一出现就创建对应 Pod(static pod)。因为容器节点里没有 systemd 服务,所以控制平面只能这样起。
考点:static pod 的定义必背——「由 kubelet 直接读本地 manifest 文件创建、不受 apiserver 调度」;因此控制平面组件在 kubectl get pods -A 里也能看到,但删掉会被 kubelet 立刻重建。crictl 是 containerd 的 docker ps 等价物。
p.18

Namespaces de Kubernetes · Kubernetes 的命名空间

▸ 原页截图 p.18 原讲义第 18 页

Ojo: no son los namespaces de Linux

注意:它们不是 Linux 的 namespace

Colisión de nombres: los namespaces de Linux (Sesión 1) aíslan procesos en el kernel.

命名冲突:Linux 的 namespace(第 1 讲)在内核里隔离进程。

Los Namespaces de Kubernetes son solo una división lógica de nombres dentro del clúster.

Kubernetes 的 Namespace 只是集群内部对名字的逻辑划分。

Misma palabra, conceptos distintos.

同一个词,两个不同的概念。

NamespaceQué contiene
defaultDonde acaban vuestros objetos si no decís otra cosa.
kube-systemLa infraestructura del clúster: CoreDNS, kube-proxy, CNI...
kube-publicInformación legible sin autenticarse. Rara vez se toca.
kube-node-leaseLatidos de los nodos, para detectar caídas rápido.

Para qué se usan de verdad: separar entornos o equipos, y ser el ámbito donde se aplican cuotas, RBAC y NetworkPolicy.

真正的用途:隔离环境或团队,并作为施加配额、RBAC 与 NetworkPolicy 的作用域。

Volverán con fuerza en la Sesión 7.

第 7 讲它们会强势回归。

终端 · 出处:Sesión 4 · p.18

$ kubectl get ns    &&    kubectl get pods -n kube-system
命令逐行说明
kubectl get ns列出全部命名空间(ns 是 namespace 的缩写)。
kubectl get pods -n kube-system-n 指定命名空间,只看系统分区里的 Pod。
&&前一条成功才执行后一条。
这段在考什么:get ns 列出四个系统命名空间;-n kube-system 把视角切到基础设施分区——同一条 get pods,换个 -n 就是另一批对象。不加 -n 只看到 default,这也是「Pod 怎么不见了」的最常见原因。
考点(最爱的陷阱题):Kubernetes Namespace ≠ Linux namespace。前者是 API 里的「名字分区」,后者是内核的隔离机制(PID/NET/MNT…)。四个系统命名空间的名字与用途也要记:default / kube-system / kube-public / kube-node-lease。
记忆钩子:kube-system 装基础设施(CoreDNS、kube-proxy、CNI),kube-node-lease 装心跳。
p.19

Tarea — primer despliegue y primera reconciliación · 任务:第一次部署与第一次调和

▸ 原页截图 p.19 原讲义第 19 页

Desplegad algo, borrad un Pod a mano y observad qué hace el clúster.

部署点东西,手动删掉一个 Pod,观察集群会做什么。

Esta es la demostración práctica del bucle de reconciliación.

这就是调和循环的实操演示。

Qué observáis: aparece un Pod nuevo con nombre distinto en segundos.

你们会看到:几秒内出现一个名字不同的新 Pod。

Nadie lo ha pedido: el ReplicaSet ha reconciliado.

没人要求它这么做:是 ReplicaSet 完成了调和。

Comprobad: ¿en qué namespace de kubernetes se están ejecutando los contenedores?

检查一下:这些容器跑在 Kubernetes 的哪个 namespace 里?

Probar varias veces y comprobad el nodo asignado.

多试几次,并确认被分配到的节点。

终端实录 · 出处:Sesión 4 · p.19

$ kubectl create deployment web --image=nginx --replicas=3
$ kubectl get pods -o wide
NAME                    READY   STATUS    NODE
web-6f9c...-abc         1/1     Running   redes-virtualizadas-worker
web-6f9c...-def         1/1     Running   redes-virtualizadas-worker2
web-6f9c...-ghi         1/1     Running   redes-virtualizadas-worker

# Ahora borrad uno a mano y mirad qué pasa
$ kubectl delete pod <nombre-de-uno-de-ellos>
$ kubectl get pods -w            # Ctrl-C para salir
命令逐行说明
kubectl create deployment web --image=nginx --replicas=3命令式创建;--image 指定镜像,--replicas 指定副本数。
get pods -o wide多出 NODE、IP 列,用来看 Pod 被调度到哪。
delete pod <nombre>手动删一个 Pod,名字从上一行输出里抄。
get pods -w-w 持续监听变化,Ctrl-C 退出。
这段在考什么:Pod 名字里的随机后缀(abc/def/ghi)说明每次重建都是新对象;3 个副本落在 2 个 worker 上说明调度是逐 Pod 进行的,且没有反亲和性约束时允许同节点重复。
考点:删掉 Pod 后自动重建,决策者是 ReplicaSet 控制器、执行者是 kubelet;新 Pod 名字不同、IP 不同——这也解释了为什么不能靠 Pod IP 做服务发现。
p.20

¿Por qué ese nodo y no otro? · 为什么是这个节点而不是另一个

▸ 原页截图 p.20 原讲义第 20 页

El trabajo del scheduler

调度器的工作

En la tarea anterior vuestros tres Pods se han repartido entre los workers, y ninguno ha ido al control-plane.

在上一个任务里,你们的三个 Pod 分布在各个 worker 上,没有一个去 control-plane。

No es casualidad: el scheduler filtra primero y puntúa después.

这不是巧合:调度器先过滤,再打分。

1. Filtrado — ¿Qué nodos PUEDEN alojar este Pod?

1. 过滤——哪些节点「能够」承载这个 Pod?

Recursos suficientes, puertos libres, selectores de nodo, taints toleradas.

资源足够、端口空闲、节点选择器、可容忍的污点。

2. Puntuación — De los que pueden, ¿cuál es MEJOR?

2. 打分——在能承载的里面,哪个「最好」?

Reparto de carga, afinidad, imágenes ya presentes en el nodo.

负载分布、亲和性、镜像是否已在节点上。

Por qué el control-plane queda excluido: lleva un "taint" (NoSchedule) que repele los Pods normales.

为什么 control-plane 被排除:它带有一个「污点」(NoSchedule),会排斥普通 Pod。

Es una marca que dice "aquí no, salvo que se tolere explícitamente".

它是一句标记:「这里不行,除非被显式容忍」。

终端 · 出处:Sesión 4 · p.20

$ kubectl describe node redes-virtualizadas-control-plane | grep -i taint
命令逐行说明
kubectl describe node ...节点完整详情:容量、条件、taint 等。
| grep -i taint-i 忽略大小写,只保留含 taint 的行。
这段在考什么:taint 与 toleration 是一对——节点打 taint(拒绝),Pod 写 toleration(接受)。查看命令用 describe node 加 grep -i taint。
考点:调度两阶段必背——Filter(能不能)→ Score(哪个更好);control-plane 不被调度是因为 NoSchedule taint,不是因为「它是主节点所以不能用」。
记忆钩子:先筛后选——筛掉不能的,再给能打的打分。

六、从命令到交付物:YAML、资源与诊断

p.21–p.23
p.21

Tarea — del comando al YAML · 任务:从命令到 YAML

▸ 原页截图 p.21 原讲义第 21 页

Los comandos "create" son cómodos para clase, pero lo que se versiona y se entrega es YAML.

「create」类命令在课堂上很方便,但真正纳入版本管理、真正交付的是 YAML。

kubectl puede generarlo por vosotros: es la forma correcta de aprender la sintaxis.

kubectl 可以替你们把它生成出来:这是学习语法的正确途径。

Fijaos: el segundo apply no da error de "ya existe": calcula la diferencia y la aplica.

注意:第二次 apply 不会报「已存在」的错——它会计算差异并应用。

Eso es trabajar declarativamente.

这就是声明式地工作。

终端实录 · 出处:Sesión 4 · p.21

# Generar el YAML sin crear nada (--dry-run=client)
$ kubectl create deployment web2 --image=nginx --replicas=2 \
    --dry-run=client -o yaml > web2.yaml
$ cat web2.yaml

# Aplicarlo de forma declarativa
$ kubectl apply -f web2.yaml

# Editad replicas: 2 -> 4 en el fichero y volved a aplicar
$ kubectl apply -f web2.yaml && kubectl get deploy web2
命令逐行说明
create deployment web2 --image=nginx --replicas=2命令式创建,立即提交给 apiserver。
--dry-run=client -o yaml > web2.yaml只在客户端生成 YAML 并重定向到文件,不发给 apiserver。
cat web2.yaml查看生成出来的清单。
apply -f web2.yaml声明式提交;改完副本数再 apply 也不会报「已存在」。
apply ... && get deploy web2&&:前一条成功才执行后一条。
这段在考什么:--dry-run=client -o yaml 是「只生成、不提交」的黄金组合——离线拿到一份可直接改的模板;kubectl apply 是声明式入口,kubectl create 是命令式入口(对象已存在就报错)。
考点:create = 命令式(只能做一次),apply = 声明式(可重复);若问「如何把命令行操作变成可交付物」,答案就是 --dry-run=client -o yaml 导出,再 apply -f 提交。
易错:-o yaml 必须与 --dry-run=client 同时出现才会把对象打印到标准输出;只写 --dry-run(不带 =client)在新版 kubectl 中会提示弃用。
p.22

Requests y limits: cgroups, otra vez · requests 与 limits:又是 cgroups

▸ 原页截图 p.22 原讲义第 22 页

El enlace con la Sesión 1

与第 1 讲的衔接

En la Sesión 1 limitasteis un contenedor con --memory y --cpus.

在第 1 讲,你们用 --memory 和 --cpus 限制过一个容器。

Kubernetes hace lo mismo, pero separa dos conceptos que Docker mezclaba.

Kubernetes 做的是同一件事,但把 Docker 混在一起的两个概念拆开了。

requests

requests

Lo que el Pod NECESITA.

Pod「需要」的量。

Es lo que usa el scheduler para decidir si cabe en un nodo. No limita nada.

这是调度器用来判断能否放进某个节点的依据。它本身不做任何限制。

limits

limits

Lo que el Pod NO PUEDE superar.

Pod「不能超过」的量。

Se traduce a cgroups.

它会被翻译成 cgroups。

Si excede memoria, el kernel lo mata (OOMKilled).

如果超出内存,内核就把它杀掉(OOMKilled)。

resources · 出处:Sesión 4 · p.22

resources:
  requests: { cpu: "100m", memory: "128Mi" }    # 100m = 0,1 CPU
  limits:   { cpu: "500m", memory: "256Mi" }
字段逐行说明
resources:容器的资源声明块,requests 与 limits 都写在这里。
requests:调度依据:Pod 至少要拿到这么多资源才被放到节点上。
limits:运行时上限:超过 CPU 被节流,超过内存被 OOMKilled。
cpu: "100m" / memory: "128Mi"100m = 0.1 核;Mi 是 2 的幂单位。
这段在考什么:100m = 0.1 CPU = 一个核的十分之一(m 是 milli,不是 MB);Mi 是 2 的幂(Mebibyte),与 M(10 的幂)不同。requests 决定「调度」,limits 决定「限制」。

Importante para la Sesión 16: sin "requests" de CPU declarados, el autoescalado (HPA) no tiene contra qué calcular el porcentaje y no funciona.

对第 16 讲很重要:没有声明 CPU 的 requests,自动扩缩容(HPA)就没有计算百分比的基准,因而失效。

考点:requests → scheduler;limits → cgroups → OOMKilled。必答的连锁题:没有 CPU requests,HPA 算不出使用率百分比,自动扩缩容失效(第 16 讲还会考)。
记忆钩子:requests 是「入场券」,limits 是「天花板」——入场券决定让不让你进节点,天花板决定你在里面能长多高。
p.23

Diagnóstico: los estados de un Pod · 诊断:Pod 的各个状态

▸ 原页截图 p.23 原讲义第 23 页

Qué significa cada uno y qué mirar

每一个状态的含义,以及该去看什么

STATUSSignificadoQué hacer
PendingAún no asignado a un nodo, o la imagen no ha bajado.kubectl describe pod → sección Events
ContainerCreatingEl nodo lo está preparando (descarga, red, volúmenes).Esperar; si tarda, describe
RunningTodos los contenedores arrancados.—
CrashLoopBackOffArranca, se muere y reinicia en bucle.kubectl logs --previous
ImagePullBackOffNo consigue descargar la imagen.Revisar nombre, tag y red
Error / OOMKilledTerminó mal, o superó el límite de memoria.Revisar limits y logs

Los tres comandos de diagnóstico: describe (qué ha intentado hacer el clúster y qué eventos ha registrado), logs (qué ha dicho vuestra aplicación) y exec (entrar y mirar desde dentro).

三个诊断命令:describe(集群尝试做了什么、记录了哪些事件)、logs(你们的应用说了什么)、exec(进去从里面看)。

Con estos tres se resuelve la inmensa mayoría de las incidencias — incluidas las de la Sesión 18.

有这三个,绝大多数故障都能解决——包括第 18 讲的那些。

考点:Pending → describe;CrashLoopBackOff → logs --previous;OOMKilled → 查 limits。三命令口诀:describe 看集群、logs 看应用、exec 看现场。
为什么 logs --previous:容器已经重启,不加 --previous 看到的是新实例的空日志,崩溃原因留在上一轮。

七、小结、作业与延伸:etcd、生产环境与参考

p.24–p.28
p.24

Síntesis de la sesión · 本课小结

▸ 原页截图 p.24 原讲义第 24 页

Declaráis — Un estado deseado, en YAML

你们声明——一个期望状态,写在 YAML 里

El clúster reconcilia — Observa, compara, actúa. Sin parar.

集群做调和——观察、比较、行动。永不停歇。

Kind lo simula — Cada nodo es un contenedor

Kind 把它模拟出来——每个节点就是一个容器

En una frase: Kubernetes no ejecuta vuestras órdenes: mantiene vuestras declaraciones.

一句话:Kubernetes 不执行你们的命令,它维护你们的声明。

Todo lo que veréis en el resto del curso — Services, políticas de red, mallas de servicio, autoescalado — son controladores aplicando ese mismo bucle a un objeto distinto.

课程余下部分你们会看到的一切——Service、网络策略、服务网格、自动扩缩容——都是控制器把同一个循环套用到另一个对象上。

En la Sesión 5 empezamos con la red de verdad: cómo se hablan dos Pods dentro de un mismo nodo.

第 5 讲我们开始讲真正的网络:同一个节点内两个 Pod 如何通信。

考点:全课的主句就是「no ejecuta órdenes, mantiene declaraciones」。若要求「用一句话总结 Kubernetes」,这句可以直接写。
记忆钩子:三张卡片 → 声明(YAML)· 调和(观察-比较-行动)· Kind(节点 = 容器)。
p.25

Para casa · 课后作业

▸ 原页截图 p.25 原讲义第 25 页

Tarea

作业

Modificad kind-cluster.yaml para añadir un tercer worker, recread el clúster (kind delete cluster --name redes-virtualizadas, y volved a crearlo) y documentad:

修改 kind-cluster.yaml 增加第三个 worker,重建集群(kind delete cluster --name redes-virtualizadas,然后重新创建),并记录:

1. Las IP internas asignadas a los cuatro nodos y en qué han cambiado.

1. 四个节点分配到的内部 IP,以及它们发生了什么变化。

2. Cómo se reparten los 3 Pods del Deployment "web" ahora que hay un worker más.

2. 多了一个 worker 之后,Deployment「web」的 3 个 Pod 如何分布。

3. Una hipótesis razonada de por qué el scheduler ha elegido ese reparto.

3. 对调度器为何这样分配,给出一个有推理依据的假设。

Adjuntad la salida de "kubectl get pods -o wide" como evidencia.

附上「kubectl get pods -o wide」的输出作为证据。

Entrega: documento breve con las tres respuestas y la captura, antes de la Sesión 5.

提交:一份含三问答案与截图的简短文档,在第 5 讲之前交。

Próxima sesión: Sesión 5 — El modelo de red de Kubernetes: comunicación Pod-to-Pod.

下一讲:第 5 讲——Kubernetes 网络模型:Pod 到 Pod 的通信。

考点:作业第 3 问就是考试题的原型——用 Filter/Score 两阶段解释分布;第 1 问考「IP 会变」这一事实(重建集群即重新分配)。
做作业的小技巧:先 kubectl get nodes -o wide 对比重建前后的 INTERNAL-IP 列,再用 describe pod 的 Node: 字段解释分布,比肉眼猜可靠。
p.26

[Opcional] Dónde vive realmente el estado: etcd · 状态到底存在哪里:etcd

▸ 原页截图 p.26 原讲义第 26 页

Solo si sobra tiempo — no imprescindible para seguir el bloque

仅当时间有剩余——不是跟上本模块的必需内容

Todo lo que declaráis acaba en etcd, un almacén clave-valor distribuido que usa el algoritmo de consenso Raft.

你们声明的一切最终都写进 etcd——一个使用 Raft 共识算法的分布式键值存储。

El apiserver es su único cliente.

apiserver 是它唯一的客户。

终端 · 出处:Sesión 4 · p.26

$ kubectl -n kube-system exec etcd-redes-virtualizadas-control-plane -- etcdctl
kubectl -n kube-system exec etcd-redes-virtualizadas-control-plane -- 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 \
get /registry/pods --prefix --keys-only
命令逐行说明
kubectl -n kube-system exec <pod> -- etcdctl在 etcd 的 Pod 里执行 etcdctl;-- 之后才是容器内的命令。
--endpoints=https://127.0.0.1:2379etcd 在 Pod 内监听的地址,所以在容器里用 localhost。
--cacert / --cert / --key双向 TLS 三件套:CA 证书、客户端证书、私钥。
get /registry/pods --prefix --keys-only按前缀列键、不返回 value,所以输出很轻。
这段在考什么:Kubernetes 的对象在 etcd 里就是「/registry/<资源类型>/<命名空间>/<名字>」这样的键;三个 TLS 参数(--cacert/--cert/--key)是因为 etcd 只接受双向 TLS,而 --prefix --keys-only 表示「按前缀列键、不取内容」,所以输出轻。

Por qué se enseña esto: para que quede claro que no hay magia: los objetos son filas en una base de datos, y el clúster es un montón de procesos vigilándola.

为什么要讲这个:为了说清楚这里没有魔法——对象就是数据库里的行,而集群不过是一堆进程在盯着这张表。

En producción: la copia de seguridad de etcd es LA copia de seguridad del clúster. Sin ella, un desastre en el control plane es irreversible.

生产环境里:etcd 的备份就是集群的备份。没有它,控制面一旦出事就不可挽回。

原文笔误:代码框第一行是「预览式」的半截命令(结尾没有续行符 \,直接断在 etcdctl),第二行起才是完整命令;照抄第一行执行只会打印 etcdctl 的帮助。
考点:唯一数据源 = etcd;唯一客户端 = apiserver;Raft 需要奇数个成员(3 或 5)才能保证 quórum。被问「为什么生产必须备份 etcd」时,答「它就是集群的全部状态」。
p.27

[Opcional] Qué cambia en un clúster real · 真实集群有什么不同

▸ 原页截图 p.27 原讲义第 27 页

Solo si sobra tiempo — no imprescindible para seguir el bloque

仅当时间有剩余——不是跟上本模块的必需内容

AspectoVuestro KindProducción
Nodos de control13 o 5 (número impar, por el quórum de Raft)
Nodos worker2 contenedoresDecenas o cientos de máquinas
Red entre nodosUn bridge Docker localRed física, con encapsulado entre nodos
AlmacenamientoDisco local del nodoCabinas o discos de red vía CSI
Acceso externoport-forward y NodePortBalanceador del proveedor cloud

Qué NO cambia: la API, los objetos, el bucle de reconciliación y todos los comandos que vais a aprender.

不变的是:API、对象、调和循环,以及你们要学的所有命令。

Por eso un clúster de laboratorio sirve para aprender: lo que se transfiere es el modelo, no la infraestructura.

所以实验集群足以用来学习:被迁移过去的是模型,不是基础设施。

考点:控制面节点数必须是奇数(1、3、5),理由是 Raft 的 quórum = 多数派;偶数不增加容错,只增加成本。被问「Kind 与生产差在哪」时,按表的五行答,最后补一句「API 与对象不变」。
记忆钩子:控制面 3/5、worker 成百、网络封装、存储 CSI、入口走云 LB。
p.28

Bibliografía y recursos · 参考文献与资源

▸ 原页截图 p.28 原讲义第 28 页

Para profundizar más allá de esta sesión:

想在本讲之外继续深入:

TipoRecurso
Doc. oficialkubernetes.io/docs/concepts/overview/components — arquitectura y componentes (CC BY 4.0).
Doc. oficialkind.sigs.k8s.io/docs/user/configuration — todas las opciones del fichero de configuración de Kind.
Referenciakubernetes.io/docs/reference/kubectl/quick-reference — la chuleta oficial de kubectl. Imprimidla.
LibroKubernetes in Action, 2ª ed. — M. Lukša (2024), capítulos 1-3.
Curso gratuitoLFS158 "Introduction to Kubernetes" (Linux Foundation), capítulos 5-6.
Prácticakillercoda.com/kubernetes — escenarios interactivos en el navegador, sin instalar nada.
考点:若被要求「给出官方架构文档地址」,答案是 kubernetes.io/docs/concepts/overview/components;Kind 配置文件的全部选项在 kind.sigs.k8s.io/docs/user/configuration。教材引用 Kubernetes in Action, 2ª ed. (Lukša, 2024)。
复习路线:先过一遍官方 components 页(15 分钟)→ 用 kubectl quick-reference 把本讲命令各敲一次 → 最后在 killercoda 上做两个交互场景检验。

专有名词速记表(A–Z)

共 40 条,覆盖全 28 页的高频术语。第三列点页码直接跳回原页;最后一列只写「一句话 + 最容易被扣分的点」。

西语术语中文页码一句话记住 · 易错点
A
apiserverapiserver,API 服务器p.26etcd 的唯一客户端;任何组件都绕不过它。
autocompletado自动补全p.14别名 k 要配 complete -F __start_kubectl k 才生效。
autoescalado自动扩缩容p.22HPA 按 CPU 百分比扩缩,所以必须先写 requests。
B
bucle de reconciliación调和循环p.2观察 → 比较 → 行动,永不停;每个控制器都是它的实例。
C
cgroupscgroups,内核资源控制组p.22limits 最终翻译成 cgroups;超内存就是 OOMKilled。
CNICNI,容器网络接口插件p.5负责 Pod 之间连通性,属于数据平面。
contextos上下文(集群 + 用户的组合)p.13kubeconfig 的三列表之一:context = 哪个 user 对哪个 cluster。
control plane控制平面p.5做决定:apiserver、etcd、scheduler、controller-manager。
controlador控制器p.4一个控制器守一种对象,跑同一个调和循环。
D
declarativamente声明式地p.21apply 可重复执行;create 是一次性的命令式。
DeploymentDeployment,管理 ReplicaSetp.8它管 ReplicaSet,ReplicaSet 才管 Pod;不要越级。
DNATDNAT,目的地址转换p.13kubeconfig 里 127.0.0.1:高位端口就是 Docker 的 DNAT。
E
estado deseado期望状态p.3写在 YAML 里的目标;系统负责让现实向它靠拢。
etcdetcd,键值存储p.5集群唯一数据源;备份 etcd 就是备份整个集群。
F
filtra过滤p.20调度的第一阶段:先筛掉「不能」的节点。
H
HPAHorizontal Pod Autoscaler,水平自动扩缩p.22没有 CPU requests 就没有百分比基准,HPA 直接失效。
I
IstioIstio,服务网格p.8给 Pod 塞 sidecar 代理;同 Pod 内容器共享 IP 是它的前提。
K
KindKind(Kubernetes IN Docker,用容器当节点)p.1每个「节点」就是一个 Docker 容器;重建集群 IP 必变。
kube-apiserverkube-apiserver,集群唯一入口p.5kubectl、控制器的所有请求都走它,RBAC 才能一处生效。
kubeconfigkubeconfig,集群连接配置p.13~/.kube/config,含管理员证书:等同密码,禁止进 Git。
kubeletkubelet,每个节点上的代理p.5数据平面代理;静态 Pod 由它直接读文件启动。
L
limitslimits,上限p.22天花板:超内存被内核杀;只限上限不保证调度。
N
namespaces de LinuxLinux 命名空间(内核隔离)p.18内核级隔离(PID/NET/MNT),与 Kubernetes 的同名概念无关。
Namespaces de KubernetesKubernetes 命名空间(逻辑分区)p.18只是 API 里的名字分区;配额、RBAC、NetworkPolicy 的作用域。
O
OOMKilledOOMKilled,超出内存被杀p.23状态是 Error 的一种;查 limits,不是查网络。
P
PodPod,最小调度单元p.8IP 属于 Pod 而不属于容器;同 Pod 内容器用 localhost。
puntúa打分p.20调度的第二阶段:在能装的节点里挑最好的。
Q
quórum法定多数p.27Raft 要多数派,所以控制面节点取奇数 3 或 5。
R
RaftRaft,共识算法p.26etcd 靠它复制日志;成员数必须是奇数。
RBACRBAC,基于角色的访问控制p.5因为所有请求都过 apiserver,权限能在一处统一控制。
reconcilia调和(观察-比较-行动)p.24同 bucle de reconciliación;手动删 Pod 被重建就是它在工作。
red bridge网桥网络p.16Kind 建一个名为 kind 的 bridge;节点间就是第 3 讲那张网。
réplicas副本p.4「quiero 3 réplicas」是声明,不是三条命令。
ReplicaSetReplicaSet,维持副本数p.8维持 N 个 Pod 存活;Deployment 通过它做滚动更新。
requestsrequests,所需资源p.22入场券:决定调度,不设上限;CPU 不写 HPA 就废。
S
scheduler调度器p.20Filter(能不能)→ Score(哪个更好)两阶段。
static pods静态 Podp.17kubelet 读本地文件直接起,不受调度器管;控制面组件就是这样跑的。
T
taint污点p.20节点拒绝 Pod 的标记;control-plane 带 NoSchedule。
toleration容忍p.20Pod 侧的「我接受这个污点」;与 taint 成对出现。
W
worker node工作节点p.5跑业务 Pod 的机器;旧文档里叫 minion。

编号规则速记卡

口诀:三观察、四层级、四控制、四数据、两筛选、三列表、六状态、三命令——本讲的编号全是「几步、几层、几个组件」,按数量背最省力。

编号原文关键词中文性质归类页
1Observar / Comparar / Actuar观察真实状态 → 与期望比较 → 纠正差异调和循环三拍(最核心)p.4
2Contenedor → Pod → ReplicaSet → Deployment从下到上:容器 → Pod → 副本集 → 部署对象层级四层p.8
3kube-apiserver / etcd / kube-scheduler / kube-controller-manager入口、状态库、选节点、跑循环控制平面四组件(决定)p.5
4kubelet / containerd / kube-proxy / CNI节点代理、容器引擎、Service 规则、Pod 连通数据平面四组件(执行)p.5
5clusters / users / contextskubeconfig 三张列表:集群地址、凭据、组合连接配置三列表p.13
6Filtrado / Puntuación先筛「能不能」,再选「哪个更好」调度两阶段p.20
7Pending / ContainerCreating / Running / CrashLoopBackOff / ImagePullBackOff / Error待调度 / 准备中 / 运行 / 崩溃重启 / 拉镜像失败 / 异常Pod 六状态p.23
8describe / logs / exec看集群、看应用、进现场诊断三命令p.23
9IP internas / reparto de Pods / hipótesis del schedulerIP 变化、Pod 分布、调度假设作业三问(第 3 问=考试原型)p.25
10Nodos de control / worker / red / almacenamiento / acceso externo控制节点、worker 数量、节点网络、存储、外部入口生产差异五方面p.27

易混概念对照卡

每一对只问一句:差别落在哪一个词上?考前扫一遍,比背定义快。

imperativo vs declarativo差在「给什么」:命令式给的是动作(arranca este contenedor),执行完就结束;声明式给的是状态(quiero 3 réplicas),系统持续让现实向它靠拢。
docker run vs kubectl apply差在「跑几次」:docker run 跑一次就完,容器死了没人管;kubectl apply 可重复执行,每次只算差异。
create vs apply差在「重复会怎样」:create 是命令式,对象已存在就报错;apply 是声明式,重复执行等于「对齐到文件里的状态」。
Pod vs contenedor差在「IP 属于谁」:IP 和存储属于 Pod,同 Pod 内的多个容器共享 IP、用 localhost 互访。Istio 的 sidecar 就靠这一点。
Deployment vs ReplicaSet差在「谁管谁」:Deployment 管的是 ReplicaSet(为了滚动更新留旧版本),ReplicaSet 才管 Pod 数量。不要越级说「Deployment 管 Pod」。
ReplicaSet vs Pod差在「删了会怎样」:手工删 Pod,ReplicaSet 立刻补一个新的——这不是 bug,是调和循环;要缩容得改副本数。
control plane vs data plane差在「决定 vs 执行」:控制平面(apiserver/etcd/scheduler/controller-manager)做决定;数据平面(kubelet/containerd/kube-proxy/CNI)干活。
kube-apiserver vs etcd差在「门 vs 库」:apiserver 是唯一入口也是 etcd 的唯一客户端;任何组件(含 kubectl、kubelet)都不能直接读写 etcd。
kube-scheduler vs kubelet差在「选 vs 跑」:scheduler 只写「Pod 该去哪」,不启动任何东西;真正拉镜像、起容器的是目标节点上的 kubelet。
Kubernetes Namespace vs Linux namespace差在「逻辑 vs 内核」:前者是 API 里的名字分区(配额/RBAC/NetworkPolicy 的作用域);后者是内核隔离机制(PID/NET/MNT)。本讲最爱的陷阱题。
requests vs limits差在「入场券 vs 天花板」:requests 只影响调度、不限制运行;limits 落到 cgroups、超了就被杀。两者可以相等,但含义不同。
CrashLoopBackOff vs OOMKilled差在「谁动手」:CrashLoop 是容器自己崩了被反复重启(看 logs --previous);OOMKilled 是内核因超内存把它杀了(看 limits)。
taint vs toleration差在「写在谁身上」:taint 写在节点上表示「别来」,toleration 写在Pod 上表示「我能接受」。control-plane 的 NoSchedule 就是这样挡住普通 Pod 的。
static pod vs 普通 Pod差在「谁创建」:static pod 由 kubelet 读本地清单直接起,不经过调度器、不受 Deployment 管;控制面组件本身就以 static pod 运行。
Kind vs 生产集群差在「节点是什么」:Kind 的节点是 Docker 容器,网络是一个本地 bridge;生产用真机/云主机、节点间封装、CSI 存储、云负载均衡——但 API 与对象完全一样。