容器与 Docker 基础 · 逐页逐句双语对照讲义

Sesión 1 — Fundamentos de contenedores y Docker · BLOQUE II
BLOQUE II — CONTENEDORES Y ORQUESTACIÓN · 共 108 页 · 2 小时(理论 + 课堂短任务)· 页码为 PDF 物理页序
怎么用这份讲义

一、课程概览:目标、环境与准备工作

p.1–p.7
p.1

Portada · 封面

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

BLOQUE II — CONTENEDORES Y ORQUESTACIÓN

第二板块——容器与编排。

Fundamentos de contenedores y Docker

容器与 Docker 基础。

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

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

1

封面右下角的页码 1(这是讲义内部印的页码,与 PDF 物理页序从第 9 页起就开始错位)。

这一页只给信息不给知识:课程名是 Contenedores y Orquestación,属于 BLOQUE II。后面 107 页都在展开「容器」这一件事,编排(Kubernetes 一类)是下一个板块。
记法:BLOQUE II 的两个词 = 先「容器」后「编排」,容器是砖,编排是图纸。
p.2

Comentarios previos. Consejos · 课前说明:学习建议

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

Comentarios previos. Consejos

课前说明·学习建议。

Algunas clases se pasará lista para tenerlo en cuenta positivamente con aquellos que trabajen en clase.

有些课会点名,课堂上动手做的人会被正面计入考核。

Para poder repasar los ejercicios, se recomienda ir guardando copias de los comandos utilizados durante las prácticas y ejercicios en clase en algún documento personal.

为了能复习练习,建议把课上实践和习题中用过的命令,持续保存到自己的一份文档里。

Por ejemplo se puede exportar el texto del terminal.

例如可以把终端的文本导出。

También algunas clases se habilitarán entregas para recoger los documentos con las anotaciones de los ejercicios y ejemplos realizados en clase.

另外有些课会开放提交入口,收走你课堂练习与示例的笔记文档。

考点式理解:这门课的分数不只来自期末,还来自「课堂参与 + 提交的命令记录」。所以每次练习完,用 history > clase_N.txt 或终端「导出文本」留档,比事后回忆划算得多。
建议固定一个目录存命令,例如 ~/rsv/clase02.txt,文件名带课次,期末复习时能按课次回放自己敲过的每条命令。
p.3

Comentarios previos. Conexión SSH a la máquina virtual · 课前说明:SSH 连接虚拟机

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

Comentarios previos. Conexión SSH a la máquina virtual

课前说明:用 SSH 连接虚拟机。

Usaremos la máquina virtual RSV-2026.

我们将使用虚拟机 RSV-2026。

Si da problemas el GUI, cambiar a SMSVGA.

如果图形界面出问题,就切换到 SMSVGA。

Para conectarse por ssh hace falta conocer la IP de la máquina virtual:

要用 ssh 连接,必须先知道虚拟机的 IP:

Se puede utilizar ifconfig

可以用 ifconfig 查看。

Puede que haya que instalar net-tools: sudo apt install net-tools

可能需要先装 net-tools:sudo apt install net-tools。

Tambien se puede usar hostname -I

也可以用 hostname -I 查看本机所有 IP。

Desde Cmd o Powershell:

在 Windows 的 Cmd 或 PowerShell 里:

ssh rsv@<direccion_ip>

ssh rsv@<虚拟机IP>(尖括号只是占位,真正敲的时候要换成实际 IP,不带尖括号)。

Password: rsv2026

密码:rsv2026。

原文 Tambien 缺重音,应为 También;<direccion_ip> 也是原样保留的占位符。另:hostname -I 是大写 I(interface),写成小写 -i 是另一个选项,查不到地址。
这一步是后面所有实验的入口:连不上 VM = 什么都做不了。考题常问「怎样在不看桌面的情况下确定虚拟机 IP」,答案两个词:ifconfig 或 hostname -I。
p.4

Comentarios previos. Instalación de docker · 课前说明:安装 Docker

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

Comentarios previos. Instalación de docker

课前说明:安装 Docker。

Comprobar primero si ya está instalado con el compando para comprobar la version (ver abajo).

先用查版本的命令确认是不是已经装好了(见下)。

En nuestra máquina RSV-2026 ya está instalado, pero si hiciera falta:

我们的 RSV-2026 机器上已经装好了,但万一需要装:

La distribucion Ubuntu ya trae una version, pero antigua:

Ubuntu 发行版自带一个版本,但很旧。

apt show docker.io | head -5

apt show docker.io | head -5(只显示前 5 行,快速看仓库里那个 docker.io 包的版本)。

Para instalar de docker:

要安装 Docker 官方版:

curl -fsSL https://get.docker.com | less

curl -fsSL https://get.docker.com | less —— 只查看脚本内容,不执行。

-- muestra solamente lo que hace

(原文旁注)——只展示脚本做了什么。

curl -fsSL https://get.docker.com | sh

curl -fsSL https://get.docker.com | sh —— 真正执行脚本。

-- ejecuta el script

(原文旁注)——执行该脚本。

Comprobar version: docker --version

检查版本:docker --version。

原文 compando 应为 comando,version 两处应为 versión,distribucion 应为 distribución——都是漏重音/笔误,原文照抄不改。
为什么先 | less 再 | sh:sh 等于把网上下载的脚本直接以你的权限跑起来,先 less 看一眼是唯一的安全习惯。curl 的四个参数背下来:-f 失败不输出、-s 静默、-S 出错仍显示、-L 跟随重定向。
常考对比:docker.io 是 Ubuntu 仓库里的旧包,get.docker.com 是官方脚本装的新版。答案关键词:versión antigua / script oficial。
p.5

Comentarios previos. Instalación de docker: Permisos · 课前说明:权限

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

Comentarios previos. Instalación de docker: Permisos

课前说明:安装 Docker 之权限。

Para las prácticas, usaremos docker con permisos de root.

实验课上我们会用 root 权限来跑 Docker。

Lo necesitaremos más Adelante en algunos ejercicios, pero no siempre sería necesario en general.

后面的某些练习会需要它,但总体上并非永远必要。

Para dar permisos, añadimos un grupo docker:

为了给权限,我们新增一个 docker 组:

sudo usermod -aG docker $USER

sudo usermod -aG docker $USER(把当前用户追加进 docker 组)。

Lo hacemos por comodidad, y para que sea más fácil trabajar sin problemas porque a alguien se le olvide hacer sudo en algunos ejemplos de las clases.

这么做是为了方便,也免得课上演示时有人忘了加 sudo 而出问题。

De nuevo, en un uso real habría que revisar esto.

再说一遍:真实生产环境里这种做法需要重新评估。

原文 más Adelante 中间的大写 A 是排版笔误,应为 más adelante。更要命的是内容本身:进 docker 组 ≈ 拿到 root(能 docker run -v /:/host 挂整个根目录),原文也提醒「真实使用要复查」。
这道题几乎必考:为什么把用户加进 docker 组等于给了 root?答题句:El demonio corre como root y el socket permite montar cualquier directorio del anfitrión.(守护进程以 root 运行,socket 允许挂载宿主机任意目录。)
口诀:docker 组 = 半个 root,别在自己笔记本上随便加。
p.6

Objetivos de esta unidad de contenido · 本单元学习目标

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

Objetivos de esta unidad de contenido

本单元内容的学习目标。

Esta sesión sienta la base conceptual de todo el bloque.

这一节课为整个板块打下概念基础。

No se asume ningún conocimiento previo de contenedores.

不预设任何容器的前置知识。

Cada concepto se comprueba inmediatamente con una tarea corta en vuestra propia VM: la idea es que se apliquen practicamente y no se queden en la teoría.

每个概念都立刻在你们自己的虚拟机上用一个小任务验证:目的是真正动手用起来,而不是停留在理论。

Qué problema resuelven los contenedores, y en qué se diferencian de una máquina virtual

容器解决什么问题,以及它和虚拟机到底差在哪。

Cómo aísla Linux: los namespaces. Cómo limita: los cgroups.

Linux 靠什么隔离:namespaces;靠什么限制:cgroups。

Cómo se origina el sistema de ficheros de un contenedor y se gestionan los cambios: Union file system

容器的文件系统怎么产生、改动怎么管理:联合文件系统(Union file system)。

Qué es exactamente una imagen, qué son las capas y qué las diferencia de un contenedor

镜像究竟是什么、什么是层、层与容器的区别在哪。

La arquitectura de Docker: cliente, demonio, registro

Docker 的架构:客户端、守护进程、注册中心。

Construir vuestra primera imagen con un Dockerfile y entender qué genera cada línea

用 Dockerfile 构建你的第一个镜像,并理解每一行生成什么。

Formato : entrelazaremos conceptos teóricos con breves ejercicios prácticos para ir fijando mejor las materias.

形式:理论与简短实操交替穿插,把内容一点点钉牢。

这 6 条 bullet 就是本讲的目录骨架,也是论述题的标准分段:①问题与 VM 对比 ②namespaces/cgroups ③联合文件系统 ④镜像·层·容器 ⑤Docker 架构 ⑥Dockerfile。答题时照这六点铺开,逻辑分直接拿满。
原文 practicamente 应为 prácticamente,Formato : 冒号前多一个空格——排版笔误,原文照抄。
五词压缩整章:namespaces 看见、cgroups 限制、UnionFS 叠层、imagen 只读、Dockerfile 造它。
p.7

El problema: "en mi máquina funciona" · 问题所在:「在我机器上明明能跑」

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

El problema: "en mi máquina funciona"

问题所在:「在我机器上明明能跑」。

Por qué apareció todo esto

这一切(容器技术)为什么会诞生。

Una aplicación no es solo su código: es su código MÁS un intérprete de cierta versión, MÁS un conjunto de bibliotecas, MÁS unos ficheros de configuración, MÁS unas variables de entorno.

一个应用不只是它的代码:而是代码 加上 某个版本的解释器、加上 一组库、加上 若干配置文件、加上 若干环境变量。

Desplegarla significaba reproducir todo eso a mano en cada máquina.

部署它就意味着在每台机器上手工把这套东西重新做一遍。

Antes

以前(的做法)。

Instalar dependencias a mano en cada servidor.

在每台服务器上手工安装依赖。

Versiones que no coinciden entre desarrollo y producción.

开发环境和生产环境的版本对不上。

Dos aplicaciones en la misma máquina que necesitan versiones incompatibles de lo mismo.

同一台机器上的两个应用,需要同一个东西的两个互不兼容版本。

Con contenedores

用了容器之后。

La aplicación y todo su entorno viajan empaquetados juntos.

应用和它整个运行环境被打包在一起一起「旅行」。

Si funciona en la imagen, funciona en cualquier sitio que ejecute contenedores.

只要在镜像里能跑,在任何能跑容器的地方都能跑。

Cada aplicación lleva sus propias versiones, sin estorbarse.

每个应用带自己的一套版本,互不干扰。

Concepto de Contenedor: un contenedor empaqueta una aplicación con su entorno completo, de forma ligera y reproducible.

容器概念:容器把应用连同完整运行环境打包,方式是轻量的、可复现的。

Ojo con "ligera": esa palabra tiene un significado técnico concreto, que veremos en dos slides. No es marketing.

注意「轻量」这个词:它有具体的技术含义,两页之后就会讲。不是营销话术。

这页是整章的「动机题」:¿Qué problema resuelven los contenedores? 标准答案三句:①应用 = 代码 + 解释器 + 库 + 配置 + 环境变量;②以前要在每台机器手工复现,于是出现版本冲突与「在我机器上能跑」;③容器把应用与环境一起打包,ligero y reproducible。关键词 reproducible 一定要写。
原文用全大写 MÁS 强调「加」,不是笔误,是排版强调,照抄即可;但答题时不要写成全大写。
「在我机器上能跑」= en mi máquina funciona,这句话在业界是梗,也是容器诞生的全部理由。

二、前身技术之一:cgroups —— 限制用多少

p.8–p.24
p.8

1a · Antecedentes. Cgroups, Namespaces y Sistemas de ficheros por capas · 第一板块(上):前身技术

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

1a

1a(讲义内部编号:第 1 部分 a 小节)。

Antecedentes.

前身技术 / 背景知识。

Cgroups, Namespaces y Sistemas de ficheros por capas

Cgroups、Namespaces 与分层文件系统。

Fundamentos de contenedores y Docker

容器与 Docker 基础(课程名,重复页眉)。

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

时长:2 小时——理论课,中间穿插短任务。

8

讲义内部印的页码 8(本页恰好与 PDF 物理页序一致)。

这是分隔页,只有标题没有正文。它的作用是给你一张地图:接下来三块内容就是容器的三根柱子——cgroups(限多少)、namespaces(看得见什么)、分层文件系统(文件怎么叠)。三者凑齐,才有「容器」。
口诀:cgroups 管配额、namespaces 管视野、UnionFS 管文件——三位一体才叫容器。
p.9

Control Groups (Cgroups) · 控制组

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

Control Groups (Cgroups)

控制组(Cgroups)。

Los grupos de control (control groups), son una caracteristica del núcleo de linux que permite limitar, medir y aislar el uso de recursos (CPU, memoria, uso de disco,…) de un conjunto de procesos.

控制组是 Linux 内核的一个特性,用来限制、计量与隔离一组进程对资源(CPU、内存、磁盘用量……)的使用。

Google comenzó a trabajar en esta característica en 2006, llamándola contenedores de procesos.

Google 于 2006 年开始做这个特性,当时叫「进程容器」。

Se cambió el nombre a control groups para eviar confusion con el término contenedor.

后来改名为 control groups,以免和「容器」这个词混淆。

Se ha extendido el soporte con controladores par memoria de kernel, firewall, …

支持范围扩展到内核内存、防火墙等控制器。

Cgroup v2, simplifica y unifica en una jerarquía única todos los controladores.

Cgroup v2 把所有控制器简化、统一到单一层级里。

Limitación: se puede configurar que un grupo no exceda el uso de memoria (u otro recurso) de un limite.

限制:可以配置某个组使用的内存(或其他资源)不超过某个上限。

Priorización: puede dar más recursos a ciertos procesos que a otros

优先级:可以给某些进程比另一些更多的资源。

Contabilidad: mide el uso de recursos

计量/记账:测量资源用量。

Control: si un grupo se excede en el uso de recursos, se pueden congelar sus procesos

控制:如果某个组超用资源,可以冻结它的进程。

Soporte a virtualización: los grupos de control son la base para varias tecnologías de virtualización.

对虚拟化的支持:控制组是多种虚拟化技术的基础。

必背四功能:Limitación / Priorización / Contabilidad / Control(限制、优先级、计量、控制)。题目若问「cgroups 能做什么」,答这四个词+一句解释即可满分;再补一句「es una característica del núcleo de Linux」,强调不是用户态软件。
原文三处笔误:caracteristica→característica;eviar confusion→evitar confusión;controladores par memoria→para memoria。考试照原文理解即可,但自己答题要写对。
历史钩子:2006 年 Google + 原名「进程容器」,因为怕和 Docker 的「容器」撞名才改叫 cgroups——记住这个梗,年份就不会忘。
p.10

Control Groups. Uso · 控制组:怎么用

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

Control Groups. Uso

控制组:使用方式。

Para usar los grupos de control, se puede:

要使用控制组,可以有以下几种途径:

Acceder manualmente al Sistema de archivos virtual cgroup

手工访问 cgroup 这个虚拟文件系统。

Mediante herramientas como cgcreate, cgexec y cgclassify (de libcgroup)

通过 cgcreate、cgexec、cgclassify 这类工具(来自 libcgroup)。

Usando el “rules engine daemon”

使用「规则引擎守护进程」。

Indirectamente a traves de otros programas, como docker, system, …

间接地通过其他程序,比如 docker、systemd……

Fuentes: Linux Foundation, Wikipedia, documentación del kernel de linux

资料来源:Linux 基金会、维基百科、Linux 内核文档。

https://docs.kernel.org/admin-guide/cgroup-v2.html)

内核官方文档地址(原文末尾多了一个右括号)。

原文 a traves 应为 a través;como docker, system, … 里的 system 几乎肯定是 systemd 的笔误(systemd 正是通过 cgroup 管服务);网址末尾多出的 ) 也是排版错误。
四种使用途径是典型的「列举题」,答题按原顺序写:①手工访问虚拟文件系统 ②libcgroup 工具 ③rules engine daemon ④通过 docker/systemd 等间接使用。少写一条就扣分。
记四个词:手工 / 工具 / 规则 / 间接。
p.11

Control Groups. Interfaces · 控制组:接口(文件清单)

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

Control Groups. Interfaces

控制组:接口。

Los grupos de control funcionan como un sistema de ficheros virtual (cgroup para v1 o cgroup2 para v2).

控制组以虚拟文件系统的形式工作(v1 叫 cgroup,v2 叫 cgroup2)。

Normalmente (se usa la version v2 y) se monta en /sys/fs/cgroup

通常(现在用的是 v2)挂载在 /sys/fs/cgroup。

En principio /sys/fs/cgroup no comienza con subcarpetas, solo con ficheros de congrol general, que se pueden consultar con “ls”

一开始 /sys/fs/cgroup 下面没有子目录,只有全局控制文件,用 ls 就能看。

cgroup.controllers

cgroup.controllers —— 本层可用的控制器列表。

cgroup.pressure

cgroup.pressure —— 整个组的资源压力(PSI)数据。

cgroup.procs

cgroup.procs —— 组内进程 PID 列表(写 PID 进去=把进程加入该组)。

cgroup.threads

cgroup.threads —— 组内线程 TID 列表(线程粒度)。

cpu.pressure

cpu.pressure —— CPU 压力指标。

cpu.stat

cpu.stat —— CPU 使用统计。

io.pressure

io.pressure —— 磁盘 I/O 压力指标。

io.stat

io.stat —— I/O 统计。

memory.pressure

memory.pressure —— 内存压力指标。

memory.stat

memory.stat —— 内存使用统计。

…

……(还有更多,省略号表示列表未穷尽)。

Pressure: Tiempo durante el que uno o más procesos de un grupo de control intentan acceder a un recursos sin éxito

Pressure(压力):控制组里一个或多个进程尝试访问某资源但没成功的那段时间。

Ejemplo: Haz ls en la ruta por defecto para el punto de montaje de los grupos de control.

练习:在控制组默认挂载点路径上执行 ls。

原文 ficheros de congrol 应为 control——把 l 和 o 打反了;versión 也漏了重音。这些不影响理解,但抄写时别跟着错。
考点三连:①挂载点 /sys/fs/cgroup;②文件名规律 <控制器>.<pressure|stat|max>;③cgroup.procs 是「往里写 PID」的入口。问「怎么把一个进程放进某个 cgroup」,答:escribir su PID en el fichero cgroup.procs del grupo。
三个文件名家族:.controllers 看有啥、.procs 放进程、.pressure 看堵不堵;每个控制器再来一套 .stat(用了多少)和 .max(最多给多少)。
p.12

Control Groups. Controladores · 控制组:控制器与启用

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

Control Groups. Controladores

控制组:控制器。

Por defecto, los controladores no se activan solos a no ser que alguien os haya activado.

默认情况下控制器不会自动启用,除非有人替你启用过。

Los controladores soportados se pueden consultar en cgroup.controllers

系统支持的控制器可以在 cgroup.controllers 里查。

Se pueden activar controladores escriviendo en “cgroup.subtree_control”:

控制器可以通过往 cgroup.subtree_control 写入来启用:

Por ejemplo: # echo "+cpu +memory -io" > cgroup.subtree_control

例如:echo "+cpu +memory -io" > cgroup.subtree_control(前面 + 表示启用,- 表示禁用)。

Ejemplo: consulta los controladores disponibles, con cat cgroup.controllers

练习:用 cat cgroup.controllers 查看可用控制器。

Ejemplo: si no está habilitado, habilita el controlador de cpu

练习:如果 CPU 控制器没启用,就把它启用。

必考细节:+ 启用、- 禁用,一次写多个控制器用空格分隔。题目常给一行 echo "+cpu -io" > cgroup.subtree_control 问含义,答:habilita el controlador de CPU y deshabilita el de I/O en los subgrupos。
原文 escriviendo 应为 escribiendo(多了一个 r)——典型的手滑笔误。另外注意 cgroup.controllers 只读(告诉你「有哪些」),cgroup.subtree_control 才是可写(决定「用哪些」)。
有一句现成的思路:controllers 是菜单,subtree_control 是点菜——加号点、减号退。
p.13

Control Groups. Consulta de versión · 控制组:查版本

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

Control Groups. Consulta de versión

控制组:查询版本。

Como hemos visto hay dos posibles versions de cgroup.

如我们所见,cgroup 可能有两个版本。

Aunque la más moderna es v2, es útil asegurarse.

虽然最新的是 v2,但确认一下总是有用的。

Se puede consultar los puntos de montaje con mount -l

可以用 mount -l 查看挂载点。

y filtrar buscando la expression cgroup con grep

再用 grep 过滤,搜索 cgroup 这个字符串。

Las versions modernas de Ubuntu usan únicamente cgroup v2

现代版本的 Ubuntu 只用 cgroup v2。

实操命令背这一条就够:mount -l | grep cgroup。输出里若看到 cgroup2 就是 v2;只看到 cgroup(没有 2)就是 v1。考试问「如何确认系统用的是哪个 cgroup 版本」,就答这条命令+判读方法。
原文 versions 两处应为 versiones,expression 应为 expresión——英语式拼写混进了西语,属笔误。
p.14

Control Groups. Crear grupos · 控制组:创建组

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

Control Groups. Crear grupos

控制组:创建组。

Para crear un grupo de control:

要创建一个控制组:

Basta con crear una subcarpeta dentro del punto de montaje de los control groups

只要在控制组挂载点里建一个子目录就够了。

Cada grupo de control debe contener sus propios ficheros para interactuar con los controladores de los distintos tipos de recursos

每个控制组都会自带一套文件,用来和各类资源的控制器交互。

Debe de haber más ficheros que en la raiz del punto de montaje. Por ejemplo:

这里的文件应该比挂载点根目录下更多。例如:

cgroup.kill, cgroup.freeze, …

cgroup.kill(杀整组)、cgroup.freeze(冻结整组)……

Para asignar procesos a un grupo de control, se escribe en /cgroup.procs ( echo <PID> | sudo tee /sys/…..)

要把进程分配进某个控制组,就往 cgroup.procs 里写(echo <PID> | sudo tee /sys/…)。

Se consulta con cat /proc/<PID>/cgroup

用 cat /proc/<PID>/cgroup 查看某进程所属的组。

Consejo para pruebas: $! Representa el PID del ultimo proceso lanzado en segundo plano con $

测试小技巧:$! 表示最后一个用 & 放到后台运行的进程的 PID。

Consejo para pruebas: $$ representa el PID del shell actual

测试小技巧:$$ 表示当前 shell 的 PID。

Puedes consultar con ps el PID de un proceso

可以用 ps 查某个进程的 PID。

Ejemplo: crea una carpeta llamada ejemplo1 dentro de /sys/fs/cgroup y consulta su contenido

练习:在 /sys/fs/cgroup 里建一个叫 ejemplo1 的目录并查看其内容。

Ejemplo : Añade el pid de tu shell actual al grupo de control, consulta el listado de procesos con cat. Busca el origen de todos los procesos incluidos en el fichero de procesos.

练习:把当前 shell 的 PID 加进该控制组,用 cat 查看进程列表,并追查文件里列出的所有进程的来源。

「创建组的唯一操作」是高频简答题:crear una subcarpeta(mkdir)。没有 cgcreate 也能建,因为 cgroup 就是个虚拟文件系统。答出「mkdir = 建组,写 cgroup.procs = 放进程」两句话就完整了。
原文 raiz 应为 raíz,ultimo 应为 último;关键那行 …en segundo plano con $ 末尾的 $ 应为 &(放到后台的符号),属排版丢失。
$$ 是我(shell),$! 是刚甩到后台的那个小家伙——两个美元符号,一个比一个「远」。
p.15

systemd-cgtop, systemd-cgls · systemd 的两个观察工具

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

systemd-cgtop, systemd-cgls

systemd-cgtop 与 systemd-cgls。

En sistemas basados en systemd, los procesos se pueden asociar a subgrupos de control

在基于 systemd 的系统里,进程可以被关联到各个控制子组。

Con system-cgls, se puede ver la jerarquía de grupos.

用 systemd-cgls 可以看到组的层级结构。

Tiene elementos slice, service y scope. Y procesos como nodos hoja.

层级里有 slice、service、scope 三类元素,进程则是叶子节点。

Con systemd-cgtop se puede listar por grupos de control por sus recursos, como con top.

用 systemd-cgtop 可以像 top 一样,按控制组列出资源占用。

原文 system-cgls 漏了 d,正确命令是 systemd-cgls;listar por grupos de control por sus recursos 里连用两个 por,读起来别扭但意思清楚:按组看资源。
两个工具的分工是标准送分题:cgls 看「树」(谁在哪个组),cgtop 看「数」(哪个组吃多少)。再补 slice / service / scope 三种单元类型,答满。
ls = list 树状,top = 实时排行,和 ls/top 的老本行一一对应。
p.16

cgroup-tools, cgroup-utils · 命令行工具箱

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

cgroup-tools, cgroup-utils

cgroup-tools / cgroup-utils(工具包名)。

El paquete cgroup-tools, proporciona herramientas para interaccional con los grupos de control de de este paquete.

cgroup-tools 这个包提供与这些控制组交互的工具。

Se puede instalar con: sudo apt install cgroup-tools

安装命令:sudo apt install cgroup-tools。

Creación de grupo de control: sudo cgcreate -g cpu,memory:/mi_grupo

创建控制组:sudo cgcreate -g cpu,memory:/mi_grupo。

Restricción de memoria: sudo cgset -r memory.max=2G /mi_grupo

限制内存:sudo cgset -r memory.max=2G /mi_grupo。

Consulta limites y restricciones con cgget , p.ej: cgget -r memory.max /mi_grupo

用 cgget 查看上限与限制,例如 cgget -r memory.max /mi_grupo。

Ejecucion de programa en un grupo: cgexec -g cpu,memory:/mi_grupo <mi_programa>

在某个组里运行程序:cgexec -g cpu,memory:/mi_grupo <mi_programa>。

Reasignacion de grupo: sudo cgclassify -g cpu,memory:/mi_grupo 1234

改组归属:sudo cgclassify -g cpu,memory:/mi_grupo 1234(把 PID 1234 挪进该组)。

Eliminación de grupo: sudo cgdelete cpu,memory:/mi_grupo

删除组:sudo cgdelete cpu,memory:/mi_grupo。

Listar todos los grupos de control creados en el sistema: lscgroup

列出系统里所有已创建的控制组:lscgroup。

En la siguiente slide veremos ejemplos practicos de estos comandos

下一页我们看这些命令的实操例子。

七条命令的名字就是考试要点:cgcreate 建 / cgset 设 / cgget 查 / cgexec 跑 / cgclassify 挪 / cgdelete 删 / lscgroup 列。注意 -g cpu,memory:/mi_grupo 的写法:控制器列表,冒号,斜杠组名。
原文 interaccional 应为 interaccionar,de de este paquete 重复了一个 de,Ejecucion / Reasignacion / practicos / limites 均漏重音(Ejecución / Reasignación / prácticos / límites)。
背成一句话:create 生、set 定、get 看、exec 跑、classify 搬家、delete 埋、lscgroup 点名。
p.17

Ejercicio en clase. Consulta de grupos · 课堂练习:查看控制组

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

Ejercicio en clase. Consulta de grupos

课堂练习:查看控制组。

Hará falta instalar mediante apt install los paquetes cgroup-tools y stress.

需要先用 apt install 安装 cgroup-tools 和 stress 两个包。

Consultar la lista de grupos usando lscgroup

用 lscgroup 查看组列表。

Por defecto, los procesos se asignan al cgroup del espacio de usuario si no tienen otro cgroup padre.

默认情况下,进程若没有别的父 cgroup,就会被分到用户空间的 cgroup 里。

Ejemplo: lanzar “stress –m 1 –t 300” ,

示例:运行 stress -m 1 -t 300(1 个内存工作进程,持续 300 秒)。

Consultar el pid de stress y también la dependencia jerárquica del proceso con ps –forest

查出 stress 的 PID,并用 ps --forest 看进程的层级依赖。

Para ver todos los procesos usar ps -ef --forest

要看到所有进程,用 ps -ef --forest。

Buscar cgroup asociado consultando el contenido del fichero virtual /proc/<pid>/cgroup

通过查看虚拟文件 /proc/<pid>/cgroup 找到它关联的 cgroup。

Comparar con el cgroup del proceso propio del Shell cat /proc/self/cgroup

用 cat /proc/self/cgroup 和 shell 自己所在的 cgroup 做对比。

Consulta el contenido del cgroup con ls /sys/fs/cgroup/user.slice… (quitando 0:: )

用 ls /sys/fs/cgroup/user.slice… 看该组内容(把输出里的 0:: 前缀去掉,就是真实路径)。

Consulta algunos ficheros del cgroup

查看组内的若干文件。

Congela (o descongela con 0) el cgroup: echo 1 | sudo tee /sys/fs/cgroup/.../cgroup.freeze

冻结该 cgroup(写 0 则解冻):echo 1 | sudo tee /sys/fs/cgroup/.../cgroup.freeze。

这套流程能直接变成实操题答案:lscgroup 看组 → stress 造负载 → /proc/<pid>/cgroup 定位 → ls 看文件 → cgroup.freeze 冻结。特别注意 /proc/self/cgroup 是「当前进程」的快捷写法,比查 PID 更快。
原文 stress –m 1 –t 300 与 ps –forest 用的是 en dash(–)而不是连字符(-),直接复制粘贴到终端会报错;正确写法是 stress -m 1 -t 300、ps --forest(长选项是两个连字符)。
stress 一开,cgroup 就现形——造个负载,再顺着 /proc/<pid>/cgroup 这条线摸上去,比死记路径快。
p.18

Ejercicio en clase. Eliminación explícita de grupo · 课堂练习:显式删除组

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

Ejercicio en clase. Eliminación explicita de grupo

课堂练习:显式删除控制组。

Abrir dos terminales Ubuntu

打开两个 Ubuntu 终端。

Consultar los cgroup

查看各自的 cgroup。

Comprobar si la dirección padre es la misma subiendo en la jerarquía

沿着层级往上走,确认父级路径是否相同。

Eliminar uno de los terminals matando su cgroup padre

通过杀掉它父级 cgroup 的方式,消灭其中一个终端。

echo 1 | sudo tee /sys/fs/cgroup/<cgroup-pid-terminal>/cgroup.kill

echo 1 | sudo tee /sys/fs/cgroup/<终端所在cgroup>/cgroup.kill(写 1 即杀掉组内全部进程)。

两个杀手锏的区别必考:cgroup.kill 杀进程(不可逆),cgroup.freeze 只是暂停(可解冻)。题目问「如何一次性结束某个组内所有进程」,答案就是往 cgroup.kill 写 1,不用逐个 kill PID。
原文 Eliminación explicita 应为 explícita(漏重音)。另外 cgroup.kill 写 1 之后终端会直接消失,别在存着未保存内容的终端里试——这是最容易踩的坑。
p.19

Ejercicio en clase. Gestión de PIDs. Paso de controladores a hijos · 课堂练习:PID 管理与控制器下传

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

Ejercicio en clase. Gestión de PIDs. Paso de controladores a hijos

课堂练习:PID 管理——控制器向子组下传。

Crear un cgroup /demo con mkdir en el punto de montaje de cgroups

在 cgroup 挂载点里用 mkdir 创建一个 /demo 组。

Añadir un nuevo cgroup hijo creando una subcarpeta /practica dentro

在里面再建一个子目录 /practica,作为子 cgroup。

Comparar el contenido de ambos

对比两者的内容。

Comparar cgroup.subtree_control en …/cgroup/demo y en /practica

比较 demo 和 practica 里的 cgroup.subtree_control。

subtree_control controla qué controladores pasan a los hijos

subtree_control 决定哪些控制器会下传给子组。

Activar la cesion del controlador de pids, con:

启用 pids 控制器的下传,命令是:

echo “+pids” | sudo tee /sys/fs/demo/cgroup.controllers

echo "+pids" | sudo tee /sys/fs/demo/cgroup.controllers(见下方勘误)。

Consultar de nuevo el contenido de /practica y comparar con el anterior

再次查看 /practica 的内容,与之前对比。

原文这条命令写了三处错:/sys/fs/demo 少了 cgroup 一级;目标文件应是 cgroup.subtree_control 而不是 cgroup.controllers(后者只读);引号是中文弯引号。正确写法:echo "+pids" | sudo tee /sys/fs/cgroup/demo/cgroup.subtree_control。原文 cesion 也应为 cesión。
这页的核心概念只有一句:控制器不会自动下传,父组必须在 subtree_control 里「放行」,子组才看得到该控制器文件。考题常问「为什么子组里没有 pids.max」,答案就是这句。
把它想成遗产继承:父组不写遗嘱(subtree_control),子组一分钱(控制器)都拿不到。
p.20

Ejercicio en clase. Gestión de PIDs (II) · 课堂练习:PID 管理(续)

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

Ejercicio en clase. Gestión de PIDs (II)

课堂练习:PID 管理(第二页)。

Si no ha funcionado el añadir pids, puede que haga falta habilitar la cesión desde el padre…

如果加 pids 没成功,可能需要先从父组启用下传……

Añadimos el Shell actual

把当前 shell 加进去。

echo $$ | sudo tee /sys/fs/cgroup/demo/cgroup.procs

echo $$ | sudo tee /sys/fs/cgroup/demo/cgroup.procs($$ 是当前 shell 的 PID)。

Limitamos el número de procesos máximo a 10 en pids.max

在 pids.max 里把进程数上限设为 10。

Consultamos los procesos del grupo

查看组内的进程。

Verificar el funcionamiento creando 12 procesos hijos con stress , o usando un bucle for con sleep.

用 stress 造 12 个子进程来验证,或者用一个带 sleep 的 for 循环。

Consultar el numero de eventos pid rechazados

查看被拒绝的 pid 事件次数。

这页的「验收信号」是 pids.events 里的 max 计数增长——它证明有 fork 被拒绝了。答实验题时写:al crear 12 procesos con pids.max=10, el contador de eventos aumenta y stress falla al hacer fork。
原文 numero 应为 número。另外注意顺序:先把 shell 放进 demo 组,之后它 fork 出来的 stress 才自动进同组;否则你限的是空气。
父进组,子跟班——cgroup 是继承制,老子在哪组,儿子就在哪组。
p.21

Ejercicio en clase. Eliminacion de cgroup · 课堂练习:删除 cgroup

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

Ejercicio en clase. Eliminacion de cgroup

课堂练习:删除 cgroup。

Con sudo rmdir, intentar eliminar el grupo demo

用 sudo rmdir 试着删掉 demo 组。

Si falla, eliminar todos los procesos del cgroup y sus hijos.

如果失败,就把这个 cgroup 及其子组里的所有进程都清掉。

21

讲义内部印的页码 21(与 PDF 物理页序一致)。

这页考的是「为什么 rmdir 会失败」:cgroup 目录里还有进程(或还有子组)就不能删,会报 Device or resource busy。标准答法:先把进程迁走或杀掉(写 cgroup.kill),再 rmdir;这与普通空目录的删除规则一模一样。
先清人,再拆房——rmdir 只拆空房子,里面还住着进程就拆不动。
p.22

Ejercicio en clase. Manejo de grupos de control (I) · 课堂练习:控制组综合(一)

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

Ejercicio en clase. Manejo de grupos de control (I)

课堂练习:控制组操作(一)。

Hará falta instalar mediante apt install los paquetes cgroup-tools y stress.

需要先 apt install 安装 cgroup-tools 与 stress。

1. Crear un grupo de control: llamarlo estudiantes, y que controle recursos de cpu y memoria

1. 建一个控制组,命名为 estudiantes,管控 CPU 与内存资源。

2. Restricción de memoria: fijar limite en 50 Mbytes con cgset, y consultar con cgget.

2. 限制内存:用 cgset 把上限设为 50 MB,再用 cgget 查询。

3. Ejecutar con cgexec una única instancia de stress en el grupo de control:

3. 用 cgexec 在该控制组里跑一个 stress 实例:

que solicite primero 10MB (usar --vm-keep para que no fluctue la memoria asignada)

先让它申请 10MB(加 --vm-keep,让分配到的内存不来回波动)。

4. Consultar procesos: desde otro terminal si hace falta:

4. 查看进程:必要时另开一个终端。

usando top, ps , cgget estudiantes, y consultando cgroup.freeze, memory.events

用 top、ps、cgget estudiantes,并查看 cgroup.freeze 与 memory.events。

Consultar sintaxis en ayuda del commando, recomendable usar timeout de 5 min p.ej.

在命令的帮助里查语法,建议顺手加个 5 分钟的 timeout。

Probar de nuevo pidiendo que stress utilice 100 MB. ¿Porqué no falla?

再试一次,让 stress 用 100 MB。为什么它没崩?

Realizar ajustes para aplicar el limite de memoria estrictamente y probar de nuevo.

作出调整,让内存上限被严格生效,然后重新测试。

这道题的「坑点」正是考点:memory.max 只是上限,进程申请超过上限的内存时,只有在真正写入(touch)时才会触发 OOM 回收/杀死;--vm-keep 让 stress 真正占住内存,才测得出限制。答案关键词:no falla porque no se ha llegado a usar la memoria, solo se ha reservado。
原文 limite 应为 límite,commando 应为 comando,Porqué 作疑问句应分开写 ¿Por qué。
申请 ≠ 使用:说「我要 100MB」不会被拦,真往里写才会被内存上限抓住。
p.23

Ejercicio en clase. Manejo de grupos de control (II) · 课堂练习:控制组综合(二)

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

Ejercicio en clase. Manejo de grupos de control (II)

课堂练习:控制组操作(二)。

Ejemplo de gestión de uso de CPUs

CPU 使用管理的示例。

1. Crear un grupo de control: llamarlo aislado, que use el controlador cpuset

1. 建一个控制组,命名为 aislado,使用 cpuset 控制器。

Recuerda usar sudo

记得加 sudo。

2. Restricción de cpus. cgset y cpuset.cpus se asigna al cgroup una única o varias cpus , p.ej 0 y 1

2. 限制 CPU:用 cgset 给该 cgroup 分配一颗或多颗 CPU,例如 0 和 1。

3. Lanzar una instancia de stress que use 3 cpus (sin asignar a cgroup)

3. 启动一个用 3 颗 CPU 的 stress 实例(先不放进 cgroup)。

4. Consulta estado de ejecución:

4. 查看运行状态:

cat /sys/fs/cgroup/aislado/cpu.stat

cat /sys/fs/cgroup/aislado/cpu.stat。

-- para ver si está siendo limitado

——看它是否正在被限流。

cat /sys/fs/cgroup/estudiantes/memory.events

cat /sys/fs/cgroup/estudiantes/memory.events。

-- para ver si ha sido eliminado (oom_kill)

——看它是否已被 OOM 杀掉(oom_kill 计数)。

cat /sys/fs/cgroup/aislado/cgroup.procs para ver procesos activos

cat /sys/fs/cgroup/aislado/cgroup.procs 查看活跃进程。

5. Mover al cgroup dinámicamente el proceso padre stress y comparar el estado observado.

5. 动态地把 stress 的父进程移进该 cgroup,对比观察到的状态。

6. Repetir si fuera necesario lanzando directamente en el cgroup o moviendo todos los procesos. ¿Qué observas en el uso de CPU?

6. 必要时重做:直接在 cgroup 里启动,或把所有进程都移进去。你在 CPU 使用上观察到什么?

原文这页有个路径不一致:第 4 步本应查 aislado 组,却给了 /sys/fs/cgroup/estudiantes/memory.events(那是上一页的内存组)。照原文保留,但理解时要知道:内存事件属于 estudiantes,CPU 统计属于 aislado。
cpuset 的关键文件只有两个:cpuset.cpus(能用哪几颗核)和 cpuset.mems(能用哪些内存节点)。题目问「如何把容器绑到指定 CPU」,答:con el controlador cpuset, escribiendo en cpuset.cpus。
cpuset 是分房,cpu.max 是限速:一个决定「在哪些核上跑」,一个决定「每秒最多跑多久」。
p.24

Consejos y referencias para los ejemplos · 示例操作技巧与参考

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

Consejos y referencias para los ejemplos.

示例操作的技巧与参考。

1. Asignar otro nombre a stress: usando (exec –a <nombre> stress <argumentos>)

1. 给 stress 换个进程名:用 (exec -a <nombre> stress <argumentos>)。

Ojo, los paréntesis (o bash –c) hacen falta para que no se cierre el terminal al usar exec

注意:必须加括号(或 bash -c),否则用了 exec 之后终端会被顶掉关闭。

Para poder lanzar varias instancias distintas y que aparezcan con distinto nombre

这样才能同时跑多个实例,并且它们在 ps 里显示不同名字。

2. Ejecución en segundo plano: si no se quiere usar otro terminal, se puede lanzar stress en segundo plano añadiendo &

2. 后台运行:不想另开终端的话,在命令末尾加 & 把 stress 放到后台。

3. Interrumpir la ejecución de stress: si se ejecuta sin timeout o con un valor muy alto, se puede interrumpir con CTRL + C si el terminal está bloqueado esperando a que termine.

3. 中断 stress:如果没加 timeout 或设得很大,而终端正卡在等它结束,用 CTRL + C 中断。

También se podría usar killall <nombre> si está en segundo plano, o Kill si se conoce el pid.

如果它在后台,也可以用 killall <nombre>;知道 PID 的话直接 kill。

4. Consulta de pid: Se puede bucar el pid de un proceso por nombre mediante pidof _nombre_

4. 查 PID:可以用 pidof <nombre> 按名字找进程的 PID。

Otra alternativa es usar ps y filtrar con | grep _nombre_

另一个办法是用 ps 配合 | grep <nombre> 过滤。

Jobs muestra procesos ejecutándose en Segundo plano

jobs 显示正在后台运行的进程。

这四条几乎就是「Linux 进程操作」小题库:改名 exec -a、后台 &、中断 Ctrl+C / killall、查 PID pidof / ps|grep / jobs。答题时按「目的 → 命令」列表写。
原文 exec –a、bash –c 用的是 en dash(–),实际应为连字符 -;bucar 应为 buscar;Segundo plano 的 S 不应大写;Kill 不应大写。
exec 会「换掉」当前 shell,所以要用括号包一层壳,给它一个替身去牺牲。

三、前身技术之二:namespaces —— 看得见什么

p.25–p.35
p.25

Control Groups y Contenedores · 控制组与容器

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

Hemos visto que los grupos de control permiten gestionar grupos de procesos de forma conjunta:

前面已经看到,控制组可以把一组进程放在一起统一管理:

Esto se aprovecha en los entornos de ejecución de contenedores

容器的运行时环境正是利用了这一点。

Un contenedor puede asignarse a un control group

一个容器可以被指定到一个控制组里。

De esa forma todos los recursos de sus subprocesos pueden gestionarse de forma conjunta

这样它所有子进程占用的资源就能被统一管理。

这一页是 cgroups 与容器之间的「桥」:题目问「容器怎么限制资源」,答 el contenedor se asigna a un control group y así se gestionan conjuntamente los recursos de todos sus subprocesos。注意「conjunta」是关键词——限的是整棵树,不是单个进程。
一句话串起来:容器 = namespaces(看不看得见)+ cgroups(用多少)+ 分层文件系统(写在哪)。这一页只讲第二块。
p.26

Namespaces (Espacios de Nombres) · 命名空间

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

Un Namespace es una funcionalidad del kernel de linux que permite aislar grupos de procesos y controlar su visibilidad y acceso a los recursos del sistema, protegiendo asi al sistema.

Namespace(命名空间)是 Linux 内核的一项功能,用来隔离进程组,控制它们对系统资源的可见性与访问权,从而保护整个系统。

Lo usan tecnologías como docker o LXC para gestionar contenedores.

Docker、LXC 这类技术就是用命名空间来管理容器的。

Se pueden crear vistas limitadas de los recursos, incluyendo:

可以创建出资源的「受限视图」,包括:

Control groups(cgroups), identificadores de procesos (PIDs), mecanismos de comunicación (IPC), interfaces de red, tablas de enrutamiento, …

控制组(cgroups)、进程标识符(PID)、进程间通信机制(IPC)、网络接口、路由表……

Los recursos asignados a un namespace se perciben como propios para los procesos de ese namespace.

分配给某个命名空间的资源,对该空间内的进程来说会被感知为「自己独有」的。

Puede haber distintos niveles de aislamiento entre namespaces.

命名空间之间的隔离程度可以分不同层级。

Referencias: Linux foundation, https://es.wikipedia.org/wiki/Espacio_de_nombres_Linux

参考:Linux Foundation;西语维基条目 Espacio de nombres (Linux)。

原文两处小瑕疵,照抄不改:protegiendo asi 应为 así;Control groups(cgroups) 括号前缺一个空格。另外原文给出的维基链接标题写作 Espacio_de_nombres_Linux,实际条目名是 Espacio de nombres (Linux),链接会重定向。
必背定义句式:Un namespace permite aislar grupos de procesos y controlar su visibilidad y acceso a los recursos。「visibilidad」和「acceso」两个词是踩分点,中文答题时也要能对应说出「可见性 + 访问权」。
cgroups 管「用多少」,namespace 管「看不看得见」——一个像宿舍的电表,一个像宿舍的门牌号。
p.27

Namespaces. Tipos (I) · 命名空间类型(一)

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

Existen distintos tipos de espacios de nombres

命名空间有多种类型。

mnt: controla lo spuntos de montaje.

mnt:管理挂载点。

pid: crea un conjunto de IDs de proceso separado de otros espacios.

pid:创建一套与其它空间彼此独立的进程 ID 集合。

Se pueden repetir IDs en distintos espacios, son independientes.

不同空间里可以出现重复的 ID,因为它们互相独立。

Están anidados, el padre puede verlos todos, pero con distinto ID

它们是嵌套的:父空间能看到全部子进程,只是编号不同。

El PID 1 de cada espacio de PID se gestiona como proceso de inicio, y termina todos los procesos del espacio si se cierra

每个 PID 空间里的 PID 1 被当作 init 进程处理;它一旦结束,该空间内所有进程都会被终止。

net:Virtualiza la pila de red. Empiezan con un interfaz de loopback.

net:虚拟化网络栈。新建时只有一个 loopback 接口。

Un interfaz se asocia solo a un espacio, pero se puede mover.

一个接口同一时间只属于一个空间,但可以移动过去。

Cada espacio tiene sus direcciones, sockets, tablas de rutas, …

每个空间都有自己的地址、socket、路由表……

ipc: gestiona comunicación entre procesos sin necesidad de usar memoria compartida.

ipc:管理进程间通信,不必依赖共享内存。

原文笔误照抄:controla lo spuntos de montaje 应为 los puntos de montaje;net:Virtualiza 冒号后缺空格;un interfaz de loopback 现代西语多写 una interfaz。
高频考点:PID 1 语义——容器里 PID 1 退出,容器就退出(termina todos los procesos del espacio si se cierra)。所以容器里跑的应用如果是 PID 1,要自己处理信号回收僵尸进程,否则会出现「kill 不掉 / 退出码怪」的现象。
net 空间出生即带 lo:所以刚 ip netns add 出来的空间,要 ip link set lo up 才能 ping 通自己。
p.28

Namespaces. Tipos (II) · 命名空间类型(二)

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

Más tipos de espacios de nombres:

更多类型的命名空间:

uts: permiten que un sistema parezca tener múltiples nombres de host y de dominio para distintos procesos.

uts:让同一个系统对不同进程呈现出不同的主机名与域名。

User: permiten aislamiento de privilegios y de usuarios.

user:实现权限与用户身份的隔离。

Hay herencia entre espacios anidados

嵌套的空间之间存在继承关系。

Se mapean al sistema mediante tablas

通过映射表与真实系统建立对应关系。

cgroups: el espacio de nombres cgroup es una capa de aislamiento para ocultar la identidad del cgroup.

cgroup:cgroup 命名空间是一层隔离,用来隐藏 cgroup 的身份(路径)。

time: permite ver diferentes tiempos de sistema

time:让不同空间看到不同的系统时间(含开机时间与单调时钟)。

syslog (propuesto): se creó journal namespace de systemd.

syslog(提案中):systemd 由此做成了 journal namespace。

IMA ( propuesto ): planea añadir verificación criptográfica de ficheros.

IMA(提案中):计划加入文件的加密校验(完整性度量)。

原文 User 与其它小写条目(mnt/pid/net/ipc/uts)大小写不一致;IMA ( propuesto ) 括号内外多余空格。均照抄原文,只在理解时按统一写法读。
「user namespace 有什么用」标准答案:aísla privilegios y usuarios mediante tablas de mapeo。它是 rootless 容器(Podman 无 root 运行)的技术底座——容器里的 root 只是映射出来的假 root。这句话写进答题能直接加分。
uts 的名字来源:UNIX Time-sharing System,因为 hostname 和 domainname 就存在这个结构里。unshare -u 之后改主机名不会影响宿主机。
p.29

Namespaces. Operaciones y Utilidades (I) · 操作与工具(一)

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

Existen herramientas y utilidades para operar con namespaces activos:

有一些工具和实用程序可以用来操作正在运行的命名空间:

lsns, utilidad de linea de commandos (del paquete util-linux)

lsns:命令行工具(来自 util-linux 包)。

/proc/<pid>/ns/<tipo> proporciona un enlace simbolico a un inodo que representa los namespaces asociados a un proceso.

/proc/<pid>/ns/<tipo> 提供一个符号链接,指向代表该进程所关联命名空间的 inode。

Llamadas de Sistema:

系统调用:

clone: crea un nuevo proceso, lo incluye en nuevos namespaces.

clone:创建新进程,并让它进入新的命名空间。

unshare: mueve al proceso a un namespace distinto de su padre

unshare:把进程移到一个与其父进程不同的命名空间里。

setns: permite asociar un namespace, usando un enlace simbolico.

setns:通过符号链接把一个命名空间关联进来(加入已存在的空间)。

ioctl: con NS_GET_PARENT o NS_GETUSERNS busca relaciones entre NS

ioctl:用 NS_GET_PARENT 或 NS_GET_USERNS 查询命名空间之间的父子/所属关系。

原文 linea de commandos 应为 línea de comandos(commandos 是「突击队」,笑死但确实是笔误);enlace simbolico 应为 simbólico;NS_GETUSERNS 内核头文件里的常量名是 NS_GET_USERNS(多一个下划线)。原文一律保留。
四个系统调用按动作记:clone 造、unshare 移、setns 进、ioctl 查。考「如何把一个进程放进已有 namespace」→ setns, usando el enlace simbólico de /proc/<pid>/ns/<tipo>。
/proc/<pid>/ns/ 下每个条目是个魔法链接,ls -l 会显示成 mnt:[4026531840] 这种 类型:[inode号] 形式——inode 号相同就是同一个空间,这是最省事的判等法。
p.30

Namespaces. Operaciones y Utilidades (II) · 操作与工具(二)

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

Más aplicaciones:

更多应用方式:

systemd integra nativamente namespaces

systemd 原生集成了命名空间。

Con PrivateNetwork=yes or PrivateTmp=yes, aisla servicios con namespaces de redes y puntos de montaje.

用 PrivateNetwork=yes 或 PrivateTmp=yes,就能借助网络与挂载点命名空间把服务隔离起来。

/proc//ns proporciona un enlace simbolico a NS asociados a un proeso

/proc/<pid>/ns 提供符号链接,指向某个进程所关联的命名空间。

(ver ejemplo) Se puede usar unshare como alternativa a chroot

(见示例)可以用 unshare 作为 chroot 的替代方案。

Ejemplo: unshare --map-root-user --fork --pid --mount-proc --root="${chrootdir}" "$@"

示例:unshare --map-root-user --fork --pid --mount-proc --root="${chrootdir}" "$@"

原文三处小错照抄:PrivateNetwork=yes or PrivateTmp=yes 的 or 应为 o(英文串进来了);/proc//ns 漏了 <pid>;proeso 应为 proceso。
这条 unshare 长命令要能拆开讲:--map-root-user 建 user ns 并把当前用户映射成 root;--fork 让新 PID 空间里有独立 PID 1;--pid 建 PID ns;--mount-proc 给新空间挂一份 /proc(不然 ps 看到的是宿主机的);--root 换根目录,等于 chroot。考「不用 chroot 怎么换根」就答这一串。
PrivateTmp=yes 是 systemd 最常用的一键隔离:服务看到的是私有的 /tmp 与 /var/tmp,别的进程看不见——典型「拿命名空间当安全开关」的例子。
p.31

Ejemplo: creando un namespace en carpeta root virtual (I) · 示例:在虚拟根目录里造一个命名空间(一)

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

Creamos una carpeta a partir de la imagen de Alpine linux:

从一个 Alpine Linux 镜像里「掏」出一个目录来:

1. Crear un contenedor sin arrancarlo. Le ponemos nombre para no tener que manejar identificadores:

1. 创建一个容器但不启动它。给它起个名字,省得后面跟一串 ID 打交道。

docker create --name temporal alpine

docker create --name temporal alpine

2. Volcar su sistema de ficheros a un fichero .tar:

2. 把它的文件系统导出成一个 .tar 文件。

docker export temporal -o alpine.tar

docker export temporal -o alpine.tar

ls -lh alpine.tar

ls -lh alpine.tar

Unos 8 MB. Ahí dentro está Alpine entero.

大约 8 MB,整个 Alpine 就在里面。

3. Descomprimirlo en una carpeta:

3. 把它解压到一个目录里。

mkdir -p ~/miniLinux

mkdir -p ~/miniLinux

tar -xf alpine.tar -C ~/miniLinux

tar -xf alpine.tar -C ~/miniLinux

ls ~/miniLinux

ls ~/miniLinux

出处 p.31(讲义截图转录)
1. Crear un contenedor sin arrancarlo. Le ponemos nombre para no tener que
manejar identificadores:
docker create --name temporal alpine
2. Volcar su sistema de ficheros a un fichero .tar:
docker export temporal -o alpine.tar
ls -lh alpine.tar
Unos 8 MB. Ahí dentro está Alpine entero.
3. Descomprimirlo en una carpeta:
mkdir -p ~/miniLinux
tar -xf alpine.tar -C ~/miniLinux
ls ~/miniLinux
这页是「不用 chroot 也能换根」的完整配方,答题三步:create(不启动)→ export 成 tar → 解包到目录。注意 docker create 和 docker run 的区别是常考点:create crea sin arrancar。
为什么是 export 而不是 save?export 导出的是容器当前的扁平文件系统(一层),save 导出的才是带所有层的镜像。这里要的就是一棵能解压的普通目录树。
p.32

Ejemplo: creando un namespace en carpeta root virtual (II) · 示例:在虚拟根目录里造一个命名空间(二)

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

4. Borrar el contenedor temporal, que ya no hace falta:

4. 删掉那个临时容器,它已经没用了。

docker rm temporal

docker rm temporal

Arrancar el contenedor

启动「容器」(原文用词,实际是进入命名空间):

unshare --map-root-user --fork --pid --mount-proc --root=$HOME/miniLinux /bin/sh

unshare --map-root-user --fork --pid --mount-proc --root=$HOME/miniLinux /bin/sh

Sin sudo. El indicador cambia a / #.

不用 sudo。提示符会变成 / #。

Aspectos a comprobar:

要检查的几点:

id

id

cat /proc/self/uid_map

cat /proc/self/uid_map

Se obtiene un id de root sin haber hecho sudo.

没敲 sudo 却拿到了 root 的 id。

Porque no es un root real del sistema, sino del espacio de nombres de usuario nuevo.

因为它不是系统里真正的 root,而是新建的 user 命名空间里的 root。

$ comando se ejecuta como usuario normal

$ 表示以普通用户执行。

# comando requiere root

# 表示需要 root。

出处 p.32(讲义截图转录)
4. Borrar el contenedor temporal, que ya no hace falta:
docker rm temporal
Arrancar el contenedor
unshare --map-root-user --fork --pid --mount-proc --
root=$HOME/miniLinux /bin/sh
Sin sudo. El indicador cambia a / #.
Aspectos a comprobar:
id
cat /proc/self/uid_map
Se obtiene un id de root sin haber hecho sudo.
Porque no es un root real del sistema, sino del espacio de nombres
de usuario nuevo.

$ comando se ejecuta como usuario normal
# comando requiere root
考题模板:「¿Se puede ser root en un contenedor sin serlo en el host?」→ Sí, mediante un user namespace con unshare --map-root-user; el root es ficticio y solo existe dentro del espacio de nombres。/proc/self/uid_map 就是那张映射表(读起来是 0 1000 1 这种格式)。
原文标题写「Arrancar el contenedor」,但执行的其实是 unshare 而不是 docker start——这里「容器」是口语化的说法(一个隔离的根目录 + 隔离的 PID 空间)。照原文保留。
uid_map 三列:空间内 ID、宿主 ID、映射长度。0 1000 1 读作「里面的 0 就是外面的 1000,只映射 1 个」。
p.33

Ejemplo: creando un namespace en carpeta root virtual (III) · 示例:在虚拟根目录里造一个命名空间(三)

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

Comprobaciones:

检查项:

Comprobación de la estructura de directorios:

检查目录结构:

ls /ss

ls /

El sistema de ficheros es el de Alpine, no el de Ubuntu.

看到的文件系统是 Alpine 的,不是 Ubuntu 的。

ps aux

ps aux

Solo hay dos procesos, y tu intéprete es el PID 1.

只有两个进程,而且你的解释器就是 PID 1。

cat /etc/os-release

cat /etc/os-release

Dice Alpine Linux… ejecutándose sobre el núcleo de Ubuntu.

它显示 Alpine Linux……但实际跑在 Ubuntu 的内核上。

Salir y limpiar

退出并清理:

exit

exit

rm -rf ~/miniLinux alpine.tar

rm -rf ~/miniLinux alpine.tar

出处 p.33(讲义截图转录)
Comprobación de la estructura de directorios:
ls /ss
El sistema de ficheros es el de Alpine, no el de Ubuntu.
ps aux
Solo hay dos procesos, y tu intéprete es el PID 1.
cat /etc/os-release
Dice Alpine Linux… ejecutándose sobre el núcleo de Ubuntu.
Salir y limpiar
exit
rm -rf ~/miniLinux alpine.tar
原文两处笔误照抄:命令写的是 ls /ss,看不出 /ss 这个目录存在的理由,应是 ls /(截图排版时多打了一个 s);正文 intéprete 应为 intérprete。
这一页就是「容器是什么」的实证:文件系统是 Alpine、进程视图只有 2 个、PID 1 是 shell、内核仍是 Ubuntu 的。答「¿Qué comparte un contenedor con el host?」→ el núcleo (kernel),其余都是隔离出来的。
「两个进程」怎么来的:/bin/sh 自己 + ps 自己。ps 一退出就只剩 1 个,所以在 PID 空间里「进程数」是动态的。
p.34

Ejemplo: creando un namespace en carpeta root virtual (IV) · 示例:在虚拟根目录里造一个命名空间(四)

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

Comprobación desde fuera, para comparar con el Sistema nativo:

从外面(宿主机)再看一遍,和原生系统作对比:

Utilizando otro terminal distinto al utilizado para lanzar unshare:

另开一个终端,不要用启动 unshare 的那个:

ls /

ls /

El sistema de ficheros es el de Alpine, no el de Ubuntu.

(原文如此)这里写的仍然是「文件系统是 Alpine 的」。

ps aux

ps aux

ps –ef –forest | grep –B2 –A2 unshare

ps -ef --forest | grep -B2 -A2 unshare

Debe observarse el proceso de llamada a unshare como padre.

应该能看到调用 unshare 的那个进程作为父进程。

cat /etc/os-release

cat /etc/os-release

Debe hacer referencia a la versión del sistema completo

它应当指向完整系统(宿主机)的版本。

出处 p.34(讲义截图转录)
Utilizando otro terminal distinto al utilizado para lanzar unshare:
ls /
El sistema de ficheros es el de Alpine, no el de Ubuntu.
ps aux
ps –ef –forest | grep –B2 –A2 unshare
Debe observarse el proceso de llamada a unshare como padre.
cat /etc/os-release
Debe hacer referencia a la versión del sistema completo
本页有两处疑似原稿复制粘贴错误,原文照抄:① 在宿主机终端 ls / 看到的应当是 Ubuntu 的根目录,正文却写成 «el de Alpine, no el de Ubuntu»(与上一页重复,逻辑上应反过来说);② 命令里的 –ef –forest –B2 –A2 用的是 en dash(–),正确写法是 ps -ef --forest | grep -B2 -A2 unshare。
这一页的考点是「同一台机器,两个视角」:空间内看是 Alpine + 2 个进程,空间外看是 Ubuntu + 全部进程,而 ps --forest 能把 unshare 及其子进程的父子关系画出来——这就是「父空间看得见子空间」的直接证据(呼应 p.27 的 anidados)。
grep -B2 -A2 = 命中行上下各带 2 行上下文,看进程树时特别好用,不用来回滚动。
p.35

Ejemplo de comunicación entre espacios de nombre de red · 示例:网络命名空间之间的通信

▸ 原页截图 p.35(页脚印 39) 原讲义第 35 页

sudo ip netns add espacio1

sudo ip netns add espacio1——建第一个网络空间。

sudo ip netns add espacio2

sudo ip netns add espacio2——建第二个。

ip netns list

ip netns list——列出已存在的网络空间。

sudo ip netns exec espacio1 /bin/bash -- añadimos un proceso porque

sudo ip netns exec espacio1 /bin/bash——先在里面起一个进程,因为……

sudo lsns --output-all | grep espacio -- sudo lsns solo dará info si hay procesos

sudo lsns --output-all | grep espacio——……lsns 只有在空间里有进程时才给得出信息。

sudo ip link add virtual1 type veth peer name virtual2

sudo ip link add virtual1 type veth peer name virtual2——造一对 veth 虚拟网线。

sudo ip link set virtual1 netns espacio1

sudo ip link set virtual1 netns espacio1——把一头塞进 espacio1。

sudo ip link set virtual2 netns espacio2

sudo ip link set virtual2 netns espacio2——另一头塞进 espacio2。

sudo ip netns exec espacio1 ip link set dev virtual1 up

在 espacio1 里启用 virtual1。

sudo ip netns exec espacio2 ip link set dev virtual2 up

在 espacio2 里启用 virtual2。

sudo ip netns exec espacio1 ip addr add 192.168.1.1/24 dev virtual1

给 virtual1 配地址 192.168.1.1/24。

sudo ip netns exec espacio2 ip addr add 192.168.1.2/24 dev virtual2

给 virtual2 配同网段的 192.168.1.2/24。

sudo ip netns exec espacio1 ping 192.168.1.2

从 espacio1 里 ping espacio2 的地址。

sudo ip netns exec espacio2 ifconfig

最后在 espacio2 里 ifconfig 看接口状态。

出处 p.35(页脚印 39,讲义截图转录)
sudo ip netns add espacio1
sudo ip netns add espacio2
ip netns list
sudo ip netns exec espacio1 /bin/bash      -- añadimos un proceso porque
sudo lsns --output-all | grep espacio          -- sudo lsns solo dará info si hay procesos
sudo ip link add virtual1 type veth peer name virtual2
sudo ip link set virtual1 netns espacio1
sudo ip link set virtual2 netns espacio2
sudo ip netns exec espacio1  ip link set dev virtual1 up
sudo ip netns exec espacio2  ip link set dev virtual2 up
sudo ip netns exec espacio1  ip addr add 192.168.1.1/24 dev virtual1
sudo ip netns exec espacio2  ip addr add 192.168.1.2/24 dev virtual2
sudo ip netns exec espacio1 ping 192.168.1.2
sudo ip netns exec espacio2 ifconfig
这套流程是网络实验的「母版」,几乎必考:add 空间 → veth 配对 → 一头一个空间 → up → 配同网段地址 → ping。答「¿Cómo se conectan dos namespaces de red?」就用 veth pair 这个词(virtual Ethernet pair),别只说 cable。
小坑:veth 建好后两头都处于 DOWN,必须先 ip link set … up;另外同一空间内 virtual1 与 virtual2 不能重名,所以塞进去之前要分别取好名字。
为什么 lsns 看不到刚建的空空间?因为网络空间是「有进程加入」才被创建出来的(ip netns add 只是建了个挂载点+文件)。所以示例里先 exec /bin/bash 留一个进程在里面。
p.36

Union File System · 联合文件系统(章节页)

▸ 原页截图 p.36(页脚印 40) 原讲义第 36 页

Union File System

联合文件系统(Union File System)。

Más aplicaciones:

(原文正文,疑为沿用)更多应用方式:

systemd integra nativamente namespaces

systemd 原生集成命名空间。

Con PrivateNetwork=yes or PrivateTmp=yes, aisla servicios con namespaces de redes y puntos de montaje.

用 PrivateNetwork=yes 或 PrivateTmp=yes 通过网络与挂载点命名空间隔离服务。

/proc/<pid>/ns proporciona un enlace simbolico a NS asociados a un proeso

/proc/<pid>/ns 提供指向进程所关联命名空间的符号链接。

这一页原文有明显的复制粘贴事故:标题换成了 Union File System,但正文三条内容(systemd、PrivateNetwork/PrivateTmp、/proc/<pid>/ns)与 p.30 完全一字不差,还带着 or 和 proeso 两个老错误。按原文照录,不作改写。
标题才是重点:从这里开始进入第三块基石——Union/Overlay 文件系统,也就是「多层目录叠成一个视图」的技术,Docker 镜像分层就靠它。内容见 p.37–p.39。
虽然正文是重复的,但标题给出的名词要会解释:Union File System permite superponer varios sistemas de ficheros (capas) y verlos como uno solo。这句话是 Docker 镜像「只读层 + 可写层」的理论前提。

四、第三块基石:UnionFS / OverlayFS —— 写在哪

p.36–p.39
p.37

Union File System / OverlayFS · 联合文件系统 / OverlayFS(一)

▸ 原页截图 p.37(页脚印 41) 原讲义第 37 页

Se recomienda crear primero una carpeta padre en la que realizar el ejemplo.

建议先建一个父目录,把实验都放在里面做。

Es útil instalar y utilizar la herramienta tree para ver de forma fácil la jerarquía completa de carpetas y ficheros en dicha carpeta padre en el proceso.

装个 tree 工具会很有用,能一眼看清这个父目录里完整的目录与文件层级。

mkdir dir1 dir2 union; touch dir1/f1 dir1/f2 dir2/f3 dir2/f4

建 dir1、dir2、union 三个目录,再在里面造 4 个空文件。

sudo mount -t overlay overlay -o lowerdir=$PWD/dir1:$PWD/dir2 $PWD/union

把 dir1 与 dir2 作为两层 lower,叠加挂载到 union。

ls union/

ls union/——两层的文件同时出现。

echo file1 > dir1/f1; echo file3 > dir2/f3; cat union/f1 union/f3

往两个底层目录里写内容,再从叠加视图里读出来。

echo unionfile2 > union/f2

试着通过叠加视图写文件。

sudo umount union; rmdir union; rm -r dir1 dir2

卸载并清理:umount → rmdir → rm -r。

En vuestras notas, comentad lo que vais observando en cada paso.

在笔记里记录每一步观察到什么。

Ojo, oficialmente no se debe de modificar los ficheros de base una vez montados (no hay garantía).

注意:挂载之后,官方规定不应再改动底层文件(没有一致性保证)。

出处 p.37(页脚印 41,讲义截图转录)
mkdir dir1 dir2 union; touch dir1/f1 dir1/f2 dir2/f3 dir2/f4
sudo mount -t overlay overlay -o lowerdir=$PWD/dir1:$PWD/dir2 $PWD/union
ls union/
echo file1 > dir1/f1; echo file3 > dir2/f3; cat union/f1 union/f3
echo unionfile2 > union/f2
sudo umount union; rmdir union; rm -r dir1 dir2
必背:mount -t overlay overlay -o lowerdir=A:B union,多个 lower 用冒号分隔,越靠左优先级越高(左边会盖住右边的同名文件)。这是 Docker 镜像分层「后一层覆盖前一层」的内核实现。
按原文顺序执行时,echo unionfile2 > union/f2 会报 Read-only file system——因为只给了 lowerdir,没有可写层,整个叠加视图就是只读的。下一页正是为此补上 upperdir,这不是你操作错了。
原文 no se debe de modificar 是口语化的赘余(规范写法 no se debe modificar);本节多次出现的「官方不建议改底层」在 p.39 有内核文档原文佐证。
p.38

Union File System / OverlayFS · 联合文件系统 / OverlayFS(二)

▸ 原页截图 p.38(页脚印 42) 原讲义第 38 页

¿Qué pasa si modificamos el fichero en la cap alta, cambia también el de capa baja?

如果在高层(可写层)修改文件,底层的那份也会跟着变吗?

Probad sobre el ejemplo anterior a hacer el cambio en un fichero en la capa unión y ver el contenido de la carpeta original.

在上一个例子的基础上,通过叠加层改一个文件,再去看原始目录里的内容。

(sintaxis completa .... lowerdir=xxxx,upperdir=yyyy,workdir=zzzz $PWD/union)

完整的语法:lowerdir=xxxx,upperdir=yyyy,workdir=zzzz $PWD/union。

Si tenéis algún problema probad a mapear un upperdir=xxx.. Por ejemplo upperdir=upper asignando un directorio donde se guardará el contenido modificable de la unión.

如果出问题,就显式指定 upperdir,例如 upperdir=upper,这个目录用来存放叠加层里可被修改的内容。

Se hace añadiéndolo con coma y sin espacios tras lowerdir=yyy…

写法是紧跟在 lowerdir=yyy 之后,用逗号连接、不能有空格。

Y si sigue da problemas a lo mejor un workdir=asignado a otra carpeta que hayáis creado.

要是还不行,再给 workdir 指定一个你另外建好的目录。

Esta carpeta se usa para operaciones intermedias de copia.

这个目录用于「复制」时的中间操作(copy-up 的暂存区)。

Consultad el contenido tanto de f1 en dir1, como de f1 en unión, como f1 en unión y en la carpeta upper.

对比查看:dir1 里的 f1、叠加层里的 f1、以及 upper 目录里的 f1。

Por cierto, ¿qué ficheros hay en upper?

顺便问一句:upper 里到底有哪些文件?

Ojo, la capa alta puede tener contenido en el momento del mount, tiene precedencia.

注意:挂载那一刻高层就可能已经有内容,而且它优先(会盖住低层的同名文件)。

核心概念就一个词:copy-up(向上复制)——只读层里的文件一旦被写,overlay 会先把整个文件复制到 upperdir 再改,所以底层原文件纹丝不动。答题模板:al escribir en un fichero de la capa baja, OverlayFS lo copia primero a la capa alta (copy-up) y modifica la copia; el original permanece intacto。
实验会看到 upper 里只出现「被改过的文件」(以及可能的 .wh. 白障文件代表删除),没动过的文件仍然只在 lower——这就是 Docker 镜像「共享只读层、只写改动」省空间的原理。
原文两处照抄不改:Y si sigue da problemas 应为 si sigue dando problemas;workdir=asignado 中间缺空格。
p.39

Union File System / OverlayFS · 联合文件系统 / OverlayFS(内核文档佐证)

▸ 原页截图 p.39(页脚印 43) 原讲义第 39 页

Ojo, aunque pueda parecer que funciona, oficialmente no se debe de modificar los ficheros de base una vez montados!!

注意:即便看起来能跑通,官方也明确不许在挂载后修改底层文件!

«Changes to the underlying filesystems while part of a mounted overlay filesystem are not allowed. If the underlying filesystem is changed, the behavior of the overlay is undefined»

「当某个文件系统已作为已挂载 overlay 的一部分时,不允许修改其底层文件系统。若底层被改动,overlay 的行为是未定义的。」

aunque añade que «will not result in a crash or deadlock».

不过文档补充说「不会因此崩溃或死锁」。

Aunque sí se permite modificar modificar la capa de escritura estando desconectada.

但在未挂载的状态下,是允许修改可写层(upper)的。

«Offline changes, when the overlay is not mounted, are allowed to the upper tree.»

「离线修改——即 overlay 未挂载时——对 upper 树是允许的。」

docs.kernel.org/filesystems/overlayfs.html:

出处:docs.kernel.org/filesystems/overlayfs.html。

原文本页有两处瑕疵,照抄不改:左上角残留一个孤立数字「1」(版式遗留);正文 modificar modificar 重复了一次动词。
这条结论在考试里常以判断/简答出现:底层可以改吗?→ 挂载期间不行(行为 undefined);卸载后改 upper 可以。记住两个英文关键词 undefined 与 offline changes,写西语答案时可以直接引文档原句,很加分。
为什么 Docker 天生安全:镜像层在容器运行期间只读且不会被改动,所有写都落在容器自己的可写层——正好符合这条内核约束。

五、前身机制:chroot / systemd-nspawn / LXC

p.40–p.48
p.40

1b · Antecedentes. Mecanismos previos de virtualización · 1b 前史:此前的虚拟化机制

▸ 原页截图 p.40(页脚印 44) 原讲义第 40 页

1b

1b——课程第 1 部分的第二个小节。

Antecedentes.

前史 / 背景。

Mecanismos previous de virtualizacion:

此前的虚拟化机制:

chroot, system-nspain, lxc

chroot、systemd-nspawn、LXC。

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

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

这是分隔页(小节封面),本身没有技术内容,但不能跳过:它宣告接下来要讲三种「容器前身」技术。页码继续按物理页序计。
原文两处笔误照抄:previous 是英语,西语应为 previos;system-nspain 应为 systemd-nspawn(少了 d,且 spawn 拼错)。另外 virtualizacion 漏了重音,应为 virtualización。
三种前身技术按「进化链」记:chroot(只隔离文件)→ systemd-nspawn(文件 + 命名空间 + cgroup)→ LXC(模板化、网络自动化)→ Docker(加分层镜像与仓库)。考题常问「chroot 和容器的区别」。
p.41

chroot · chroot 换根隔离

▸ 原页截图 p.41(页脚印 45) 原讲义第 41 页

Proporciona aislamiento de ficheros, pero no en otros aspectos:

它只提供文件系统层面的隔离,其它方面一概不管。

Creamos un subespacio de ficheros: sudo mkdir /mnt/alpine

建一个文件子空间:sudo mkdir /mnt/alpine。

miniroot, curl desde: https://dl-cdn.alpinelinux.org/alpine/latest-stable/releases/x86_64/

用 curl 下载 miniroot:https://dl-cdn.alpinelinux.org/alpine/latest-stable/releases/x86_64/。

Comprobamos tar: tar -tzf alpine-minirootfs-xxxxxxx.tar.gz | head

先看看包里有什么:tar -tzf … | head(-t 列出、-z gzip、-f 文件)。

Extraemos tar: sudo tar -xzf alpine-minirootfs-xxxxxxx.tar.gz -C /mnt/alpine

解压到目标目录:sudo tar -xzf … -C /mnt/alpine。

Verificamos version del host: cat /etc/os-release

先确认宿主机版本:cat /etc/os-release。

Lanzamos bash aislado en carpeta alpine: sudo chroot /mnt/alpine/ /bin/sh

在 alpine 目录里启动隔离的 shell:sudo chroot /mnt/alpine/ /bin/sh。

Verificamos el sistema invitado: ls /; cat /etc/os-release

验证「来宾」系统:ls / 与 cat /etc/os-release。

Comprobamos espacio de procesos: ps aux ; hostname; ip a

检查进程空间与网络:ps aux、hostname、ip a。

Montar procesos (no sudo en alpine): mount -t proc proc /mnt/alpine/proc

挂载 proc(alpine 里没有 sudo,用 root 直接执行):mount -t proc proc /mnt/alpine/proc。

Comprobamos desde dentro, también desde fuera: ps -ef --forest | head -30

从里面看、也从外面看:ps -ef --forest | head -30。

Si falla el dns: sudo resolvectl dns enp0s3 1.1.1.1 8.8.8.8

DNS 不通时:sudo resolvectl dns enp0s3 1.1.1.1 8.8.8.8。

Desmontar proc al salir: umount /mnt/alpine/proc

退出前卸载 proc:umount /mnt/alpine/proc。

Se puede hacer algo similar en debian con debootstrap

在 Debian 上可以用 debootstrap 做类似的事。

考「chroot 的局限」就答三句:solo aísla el sistema de ficheros; no aísla procesos, red ni usuarios; y no limita recursos。这也是为什么 chroot 不算容器——它缺 namespaces 和 cgroups 这两块。
原文 Verificamos version del host 漏重音,应为 versión。另外注意 chroot 之后 ps 仍然看到宿主机全部进程(如果之前没挂 proc),这恰恰是「chroot 不隔离进程」的现场证据。
为什么先 tar -tzf 再解压?防止把归档解到错误目录,也顺便确认包结构里没有多余的顶层目录(Alpine minirootfs 的根就是 /)。
p.42

systemd-nspawn (I) · systemd-nspawn(一)

▸ 原页截图 p.42(页脚印 46) 原讲义第 42 页

Proporciona aislamiento en muchos aspectos para la jerarquia de systemd.

对 systemd 的层级体系提供多方面的隔离。

Instalar paquete de utilidades de systemd: sudo apt install -y systemd-container

安装 systemd 工具包:sudo apt install -y systemd-container。

Creamos carpeta para el contenedor systemd para alpine: mkdir ~/alpine

给 alpine 的容器建目录:mkdir ~/alpine。

Instanciamos el contenedor: sudo systemd-nspawn -D ~/alpine-container /bin/sh

实例化容器:sudo systemd-nspawn -D ~/alpine-container /bin/sh。

Consultamos desde otro terminal los procesos: ps af | grep -B5 " \-sh"

在另一个终端查进程:ps af | grep -B5 " -sh"。

Comparamos con la vista de procesos desde el propio contenedor: ~# ps

再和容器内部看到的进程视图对比:~# ps。

Consultamos la versión del OS: cat /etc/os-reléase

查操作系统版本:cat /etc/os-release。

Comprobamos hostname: hostname

查主机名:hostname。

Consulta del cgroup: cat /proc/<pid>/cgroup

查 cgroup 归属:cat /proc/<pid>/cgroup。

Consulta cgroups: systemd: systemd-cgls

用 systemd 查 cgroups:systemd-cgls……

ó

或者……

systemd-cgls /machine.slice

systemd-cgls /machine.slice(nspawn 的容器都挂在 machine.slice 下)。

本页有路径不一致:第 3 步建的是 ~/alpine,第 4 步却用 -D ~/alpine-container,两者对不上(原文如此)。另外 /etc/os-reléase 是重音错位,正确为 /etc/os-release。
-D(--directory)指定容器的根目录。答「systemd-nspawn 比 chroot 多了什么」→ aísla también procesos, red, hostname y usa cgroups,即把 namespaces + cgroups 一起用上。
为什么 grep 要找 " -sh"(前面带空格)?为了只匹配 -sh 这个 argv,而不是把 bash 之类的子串一起捞出来——课堂上的小技巧,grep -B5 顺带看父进程链。
p.43

Para lanzar un proceso en el mismo entorno de otro proceso · 在另一个进程的环境里启动进程(nsenter)

▸ 原页截图 p.43(页脚印 47) 原讲义第 43 页

Para lanzar un proceso en el mismo entorno de otro proceso

要想在另一个进程的同一套环境里启动一个新进程:

sudo nsenter -t <pid_proceso_objetivo> -m -u -i -p -r -w /bin/sh

sudo nsenter -t <pid_proceso_objetivo> -m -u -i -p -r -w /bin/sh

-t el PID del proceso cuyo entorno quieres compartir

-t:目标进程的 PID,也就是你想共享其环境的那个进程。

-m -u -i -p montajes, nombre de maquina, IPC y procesos

-m -u -i -p:分别对应挂载点、主机名(uts)、IPC 与进程(pid)命名空间。

-r usar su raiz del sistema de ficheros

-r:使用它的文件系统根目录(root)。

-w situarte en su directorio de trabajo

-w:把自己放到它的工作目录里。

必背六件套:-t 目标、-m 挂载、-u 主机名、-i IPC、-p 进程、-r 根、-w 工作目录。经典用途:容器里没有 ssh 也没有 shell 时,从宿主机 nsenter -t <容器PID> -m -p -r /bin/sh 直接钻进去排障(俗称「容器逃逸式调试」,合法版本)。
注意 -r 与 -w 是 nsenter 的选项而不是「进入 namespace」——它们改的是 chroot 与 cwd,所以能顺手把提示符变成容器里的路径。
nsenter 与 setns 的关系:nsenter 是 util-linux 提供的命令行外壳,底层干的就是对每个 -m/-u/-i/-p 调用一次 setns()。
p.44

systemd-nspawn (II) · systemd-nspawn(二)

▸ 原页截图 p.44(页脚印 48) 原讲义第 44 页

En el contenedor: cat /proc/1/cgroup

在容器里看 PID 1 归属哪个 cgroup:cat /proc/1/cgroup。

ls /sys/fs/cgroup

列出 cgroup 挂载点:ls /sys/fs/cgroup。

ls /sys/fs/cgroup/systemd

看 systemd 自己的层级:ls /sys/fs/cgroup/systemd。

cat /sys/fs/cgroup/systemd/cgroup.procs

列出该组里的进程:cat /sys/fs/cgroup/systemd/cgroup.procs。

Consulta contenedores: machinectl list

查有哪些容器:machinectl list。

Referencia: machinectl --help

参考:machinectl --help。

Consulta estado: machinectl status alpine

查状态:machinectl status alpine。

Finalizacion de contenedores: machinectl terminate alpine

结束容器:machinectl terminate alpine。

Se sale desde el propio contenedor contenedor con: exit o logout.

从容器的 shell 里退出:exit 或 logout。

machinectl 的四件套必记:list 列表 / status 详情 / terminate 终止 / login 登入。题目问「用什么工具管理 systemd-nspawn 容器」→ machinectl, del paquete systemd-container。
原文两处照抄:Finalizacion 应为 Finalización;desde el propio contenedor contenedor 重复了「contenedor」。
/sys/fs/cgroup/systemd/cgroup.procs 是 v1 层级下的写法;在纯 cgroup v2 的系统上,systemd 的位置是 /sys/fs/cgroup/system.slice/… 或 /sys/fs/cgroup/init.scope——看到路径对不上,先别慌,先 stat -fc %T /sys/fs/cgroup 看版本。
p.45

LXC · LXC(一)

▸ 原页截图 p.45(页脚印 49) 原讲义第 45 页

LXC utiliza plantillas de descarga de imágenes desde images.linuxcontainers.org

LXC 用模板从 images.linuxcontainers.org 下载镜像。

Utiliza comandos para gestionar el ciclo de vida de contenedores (similar a Docker)

用一组命令管理容器生命周期(与 Docker 类似)。

Crear, Arrancar, Parar, Inspeccionar y Destruir.

创建、启动、停止、检查、销毁。

Soporta ejecución de contenedores CON y SIN PRIVILEGIOS.

支持有特权与无特权两种容器运行方式。

LXC incluye y arranca un sistema de iniciación completo (OpenRC).

LXC 内含并会启动一套完整的 init 系统(OpenRC)。

Cuando el contenedor se enciende, arranca servicios en segundo plano (como syslog, cron, o un servidor SSH), gestiona niveles de ejecución y permite habilitar servicios con rc-update.

容器一开机,就会在后台拉起 syslog、cron、SSH 服务等,管理运行级别,并可用 rc-update 启用服务。

「LXC 与 Docker 的区别」标准答法:LXC 跑的是完整的系统(带 init、多服务),Docker 一个容器通常只跑一个进程。西语表述:LXC arranca un sistema de iniciación completo; Docker está orientado a un proceso por contenedor。
有特权 / 无特权:有特权 = 容器内 root 就是宿主 root(危险);无特权 = 通过 uid/gid 映射成假 root(安全,见下一页)。这正是今天 rootless 容器的雏形。
原文列表符号后面单独一个「-」和孤立的「.」是排版残留,内容已完整对应上面的五行。
p.46

LXC (II) · LXC(二)

▸ 原页截图 p.46(页脚印 50) 原讲义第 46 页

Instalación de LXC: sudo apt install –y lxc

安装 LXC:sudo apt install -y lxc。

Chequeo de versión vLXC: lxc-info –versión

查版本:lxc-info --version。

Chequeo de configuración: sudo lxc-checkconfig

检查内核配置是否支持:sudo lxc-checkconfig。

Habilitar servicio de puente de red: sudo systemctl enable --now lxc-net

启用网桥服务:sudo systemctl enable --now lxc-net。

Consulta de estado del puente de red: sudo systemctl status lxc-net

查网桥服务状态:sudo systemctl status lxc-net。

原文两处错误照抄:两条命令里的 –y、–versión 用的是 en dash(–),应为连字符;且 lxc-info –versión 的正确形式是 lxc-info --version(这里是英文单词 version,不是西语 versión)。另外标题里的 vLXC 应为 de LXC。
lxc-net 会在宿主机上创建 lxcbr0(默认 10.0.3.1/24)并做 NAT,容器靠它出网。考题问「LXC 容器默认怎么联网」→ a través del puente lxcbr0 que gestiona el servicio lxc-net。
lxc-checkconfig 是最容易踩坑的一步:它逐项列出内核是否开启 namespaces、cgroups、veth 等,输出里全是 enabled 才说明环境就绪。
p.47

LXC (III) · LXC(三)

▸ 原页截图 p.47(页脚印 51) 原讲义第 47 页

Creacion de contenedor alpine (con privilegios) : sudo lxc-create --name alpine-super --template download -- --dist alpine --release edge --arch amd64

创建有特权的 alpine 容器:sudo lxc-create --name alpine-super --template download -- --dist alpine --release edge --arch amd64

Consulta estado contenedores creados: sudo lxc-ls --fancy

查看已创建的容器:sudo lxc-ls --fancy。

Arranque del contenedor: sudo lxc-start --name alpine-super

启动容器:sudo lxc-start --name alpine-super。

Inspección del contenedor: sudo lxc-info –name alpine-super

查看容器信息:sudo lxc-info --name alpine-super。

Consulta pid/userid/groupid: ps -p 48213 -o pid,uid,gid,comm

查 PID / 用户 ID / 组 ID:ps -p 48213 -o pid,uid,gid,comm(48213 是示例里容器 init 的 PID)。

Enlazar a shell inside the container: sudo lxc-attach --name alpine-super --clear-env

接到容器内部的 shell:sudo lxc-attach --name alpine-super --clear-env。

Comprobar la versión de kernel: cat /proc/version

确认内核版本(注意:是宿主机的内核):cat /proc/version。

Parar el contenedor (y después listar): sudo lxc-stop –name alpine-super

停止容器(然后重新列一下):sudo lxc-stop --name alpine-super。

Eliminar contenedor (y volver a listar): sudo lxc-destroy --name alpine-super

销毁容器(再列一次):sudo lxc-destroy --name alpine-super。

LXC 命令族按「动词 + 对象」记:lxc-create / lxc-start / lxc-info / lxc-attach / lxc-stop / lxc-destroy / lxc-ls,和 Docker 的 create/start/inspect/exec/stop/rm/ps 一一对应——这正是「Docker 抄了 LXC 的作业又加了镜像」的由来。
原文三处瑕疵照抄:Creacion 应为 Creación;lxc-info –name、lxc-stop –name 用了 en dash(–);Enlazar a shell inside the container 是西英混杂,可读作 enlazar a una shell dentro del contenedor。
--clear-env 的作用:不把宿主机的环境变量带进容器,避免 PATH、LANG 之类互相污染——排障时若发现容器里命令找不到,先想到它。
p.48

LXC (IV) · LXC(四):无特权容器

▸ 原页截图 p.48(页脚印 52) 原讲义第 48 页

Creacion de contenedores sin privilegios

创建无特权容器。

Sin entrar en todos los detalles, require:

不展开全部细节,它要求:

Requiere mapear los ID de Usuario y grupo entre el Usuario normal y root.

需要在普通用户与 root 之间做用户 ID、组 ID 的映射。

Permitir al Usuario crear interfaces virtuales

允许该用户创建虚拟网络接口。

Crear ficheros de mapeo de identidades yd e control de acceso por Usuario.

创建身份映射文件,以及按用户划分的访问控制文件。

原文三处笔误照抄:require 是英语,西语应为 requiere;yd e control 应为 y de control;Creacion 漏重音;另外几处 Usuario 不该大写。
这三条对应两个具体文件:/etc/subuid 与 /etc/subgid(可映射的 ID 段),以及 lxc-usernet(授权普通用户建 veth/bridge)。答题写到文件名会明显更像「读过文档」。
一句话价值:无特权容器 = 用 user namespace 把容器里的 root 映射成宿主上的普通用户,即使容器被攻破,拿到的也只是个普通账号——这就是今天 Podman rootless 的思路来源。

六、从虚拟机到容器:真正的差别在哪

p.49–p.52
p.49

1c · 分隔页:Estándares de Contenedores y aspectos comunes · 容器标准与共性问题

▸ 原页截图 p.49(页脚印 53) 原讲义第 49 页

1c

「1c」——这是第三部分(Bloque 1c)的章节分隔页。

Estándares de Contenedores y aspectos comunes

容器标准与共性问题。

Fundamentos de contenedores y Docker

容器与 Docker 基础(课程总标题)。

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

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

分隔页别跳过:它本身没有知识点,但它宣告了接下来这一段的主题——先讲「虚拟机 vs 容器」把概念钉死,再讲「标准化 / OCI」把生态钉死。翻页时在脑子里过一遍这两步,后面 50 多页的 Docker 命令就有了挂靠点。
这一页对应印页码 53,物理页序 49,差 4 页——越往后偏移越大(到 p.108 时差 14 页)。引用页码时务必说明用的是物理页序,别和老师 PPT 里印的数字对不上。
p.50

Máquina virtual frente a contenedor · 虚拟机 vs 容器:差别到底在哪

▸ 原页截图 p.50(页脚印 54) 原讲义第 50 页

Máquina virtual frente a contenedor

虚拟机与容器之对比。

Dónde está la diferencia real

真正的差别在哪里。

Una VM virtualiza el hardware: sobre él arranca un sistema operativo invitado completo, con su propio kernel.

虚拟机虚拟化的是硬件:在虚拟硬件之上启动一个完整的来宾操作系统,并且带自己的内核。

Un contenedor no virtualiza nada — es un proceso normal del sistema anfitrión, al que se le ha restringido lo que ve y lo que consume.

容器什么也不虚拟化——它就是宿主机上一个普通进程,只是被限制了「看得见什么」和「能用多少资源」。

App A / App B / SO invitado / SO invitado / Hipervisor / SO anfitrión + hardware

左图从上到下:应用 A、应用 B → 来宾操作系统 ×2 → 虚拟机管理程序(Hypervisor)→ 宿主机操作系统 + 硬件。

App A / App B / Docker Engine / Kernel del SO anfitrión (compartido) / Hardware

右图从上到下:应用 A、应用 B → Docker Engine → 宿主机内核(共享)→ 硬件。

Máquina virtual: un kernel por VM

虚拟机:每台 VM 一个内核。

Contenedor: un solo kernel, compartido

容器:只有一个内核,大家共享。

De ahí las tres consecuencias: arranca en milisegundos (no hay kernel que iniciar), ocupa decenas de MB (no incluye kernel), y solo puede ejecutar aplicaciones compatibles con el mismo kernel.

由此得出三个直接后果:启动只需毫秒级(没有内核要引导)、体积只有几十 MB(不含内核)、并且只能运行与同一内核兼容的应用程序。

出处 p.50(讲义示意图转录,左右对照)
Máquina virtual                       Contenedor
┌─────────┬─────────┐                ┌─────────┬─────────┐
│  App A  │  App B  │                │  App A  │  App B  │
├─────────┴─────────┤                ├─────────┴─────────┤
│  SO invitado (1)  │                │   Docker Engine   │
│  SO invitado (2)  │                ├───────────────────┤
├───────────────────┤                │ Kernel del SO     │
│    Hipervisor     │                │ anfitrión (compartido)
├───────────────────┤                ├───────────────────┤
│ SO anfitrión + HW │                │     Hardware      │
└───────────────────┘                └───────────────────┘
      un kernel por VM                    un solo kernel, compartido
这一页是整门课的「第一原理」,闭卷必考:VM 隔离在硬件层(Hypervisor 之上),容器隔离在内核层(namespaces + cgroups 之内)。答「容器为什么快」永远要落到「不引导内核、共享内核」这一点,别只写「因为轻量」。
一句话反杀面试题:「容器是轻量级虚拟机吗?」——不是。虚拟机是「造一台假电脑」,容器是「给一个真进程戴上眼罩和手铐」。眼罩 = namespaces,手铐 = cgroups,这两样 p.25–p.35 已经讲过。
注意承重句里的破折号:no virtualiza nada — es un proceso normal,作者用 em dash 强调「什么也没虚拟化」。中文若译成「几乎不虚拟化」就丢掉了这层强调,答题时也会被扣分。
p.51

Ventajas e inconvenientes · 优缺点:共享内核的代价

▸ 原页截图 p.51(页脚印 55) 原讲义第 51 页

Ventajas e inconvenientes

优点与缺点。

De compartir kernel o no hacerlo

取决于是否共享内核。

Aspecto / Máquina virtual / Contenedor

对比维度 / 虚拟机 / 容器。

Tiempo de arranque: decenas de segundos / milisegundos

启动时间:几十秒 / 毫秒级。

Tamaño típico: varios GB / decenas o cientos de MB

典型体积:数 GB / 几十到几百 MB。

Aislamiento: fuerte, kernel propio / menor, kernel compartido

隔离性:强(自带内核)/ 较弱(共享内核)。

Sistemas que puede ejecutar: cualquiera / solo compatibles con el kernel del anfitrión

可运行的系统:任意系统 / 只能是与宿主机内核兼容的系统。

Densidad por máquina: unidades o decenas / cientos

单机密度:几台到几十台 / 数百个。

Aspecto de seguridad: como el kernel es compartido, un fallo en el kernel puede afectar a TODOS los contenedores de esa máquina.

安全层面:由于内核是共享的,内核中的一个漏洞可能影响该机器上所有容器。

Una VM es una frontera de seguridad más fuerte que un contenedor.

虚拟机是比容器更强的安全边界。

Por eso los proveedores cloud siguen usando VMs para separar clientes distintos, y contenedores dentro de cada una.

所以云厂商仍然用虚拟机来隔离不同租户,再在每台虚拟机内部跑容器。

Aspecto(维度)Máquina virtual(虚拟机)Contenedor(容器)
Tiempo de arranqueDecenas de segundosMilisegundos
Tamaño típicoVarios GBDecenas o cientos de MB
AislamientoFuerte: kernel propioMenor: kernel compartido
Sistemas que puede ejecutarCualquieraSolo compatibles con el kernel del anfitrión
Densidad por máquinaUnidades o decenasCientos
这五行对比是最稳的送分点,尤其最后一行「密度」:容器能到数百,VM 只有个位数到几十。另有暗坑——「容器能跑 Windows 吗?」在 Linux 宿主机上不能,因为共享的是 Linux 内核;要跑就得换 Windows 内核的宿主机或开 VM。
安全段落里 TODOS 全大写是作者刻意强调(西语正体本不需要大写),翻译和答题时都要把这个「全部」突出出来,别弱化成「其他容器」。
现实架构记一句:「VM 隔租户,容器隔应用」——公有云里你拿到的是一台 VM,VM 里再跑一堆容器。这也解释了为什么「容器不安全」并不等于「云不安全」,因为外层还有 VM 这道硬边界。
p.52

Definición de trabajo · 工作定义:三个维度一句话

▸ 原页截图 p.52(页脚印 56) 原讲义第 52 页

Definición de trabajo

工作定义(本课程采用的操作性定义)。

Namespaces — Qué VE

namespaces —— 决定它看得见什么。

cgroups — CUÁNTO consume

cgroups —— 决定它消耗多少。

Imagen — QUÉ ejecuta

镜像 —— 决定它运行什么。

En una frase: un contenedor es un proceso normal de Linux con namespaces (aislamiento) y cgroups (límites) aplicados, ejecutando el contenido de una imagen.

一句话说:容器就是一个普通 Linux 进程,套上了 namespaces(隔离)与 cgroups(限额),运行着某个镜像的内容。

Sin virtualización de hardware y sin magia: todo lo que hace Docker es pedirle esas tres cosas al kernel.

没有硬件虚拟化,也没有魔法:Docker 所做的一切,就是向内核要这三样东西。

Unidad 2: nos centramos en un solo namespace, el de red. Es el que decide cuánto aislamiento tiene un contenedor.

第二单元:我们只聚焦一个 namespace——网络命名空间。它决定了一个容器到底有多隔离。

这一段是「容器定义」的标准答案模板:普通进程 + namespaces + cgroups + 镜像,四要素少一个都不完整。考试里凡是问「什么是容器」,先写这句,再展开三块基石。
记忆口诀(西语版更好背):«Namespaces: qué VE. cgroups: CUÁNTO. Imagen: QUÉ.» 三个疑问词 VE / CUÁNTO / QUÉ 押在一起,念两遍就记住了——而且全是 SIELE 口语里能直接用的疑问词。
承上启下:本页把 p.8–p.24(cgroups)和 p.25–p.35(namespaces)正式接到 Docker 上;同时预告 Unidad 2 只讲网络命名空间——因为网络的隔离程度全靠它,桥接、NAT、overlay 全从这里长出来。

七、标准化与 OCI 三规范

p.53–p.55
p.53

Estándares de Contenedores · 容器标准:为什么需要标准化

▸ 原页截图 p.53(页脚印 57) 原讲义第 53 页

Estándares de Contenedores

容器标准。

La diversidad de implementaciones creó fragmentación.

实现方式的多样化造成了碎片化。

Para evitarla, han ido apareciendo e integrándose éstandares de contenedores.

为避免碎片化,容器标准陆续出现并不断整合。

Buscando facilitar interoperabilidad y movimiento de contenedores entre entornos.

目的是方便互操作性,以及容器在不同环境之间的迁移。

App Container Standard se integró en Open Container Initiative.

App Container Standard 被整合进了 Open Container Initiative(OCI)。

Incorporando firma de imágenes, gestión de dependencias y soporte de pods.

并带入了镜像签名、依赖管理以及 pod 支持。

两处照抄提醒:éstandares 重音位置错了,正确是 estándares(重音在 tá);左上角孤立的「1」是模板残留的编号,不是正文。
关键词三连必背:fragmentación → interoperabilidad → movimiento entre entornos。标准化的本质不是「统一技术」,而是「让镜像和容器能跨工具、跨云搬来搬去」——这正是 Docker 镜像能跑在 Podman、Kubernetes 上的原因。
历史小料:App Container Standard(由 CoreOS 主导的 appc 规范)后来被 OCI 吸收,同时带进了「镜像签名」和「pod」概念——后者直接长成了今天的 Kubernetes Pod。所以说 Pod 不是 K8s 发明的,是标准之争的遗产。
p.54

Open Container Initiative (OCI) · OCI 三份规范

▸ 原页截图 p.54(页脚印 58) 原讲义第 54 页

Open Container Initiative (OCI)

开放容器倡议(OCI)。

Se creó en 2015 por Docker y otros miembros para crear estándares abiertos de formatos y entornos de contenedores.

2015 年由 Docker 及其他成员共同创建,目的是制定容器格式与运行环境的开放标准。

Runtime Specification

运行时规范(Runtime Specification)。

Fichero de configuración,…

配置文件……(规定容器如何被创建与启动)。

Operaciones sobre contenedores, …

对容器的各种操作……(create / start / kill / delete 等生命周期动作)。

Image Specification

镜像规范(Image Specification)。

Manifiestos de configuración y capas

配置清单与层(manifest + layers)。

Indice de manifiestos para distintas plataformas, ..

面向不同平台的清单索引(manifest index,多架构镜像靠它)。

Distribution Specification

分发规范(Distribution Specification)。

Protocolo API para distribución de imágenes

用于镜像分发的 API 协议(也就是 pull / push 的接口)。

三份规范按「跑 / 存 / 传」记:Runtime = 怎么跑(runc 是其参考实现)、Image = 装什么(manifest + layers)、Distribution = 怎么传(Registry API)。这是本章最高频的选择题出处,三个词必须能一一对上。
两处照抄:Indice 应为 Índice(漏重音);左上角孤立「1」同 p.53,是模板残留。另外两处省略号后混用了 ,… 和 ,..,原文如此。
落到实物上:Docker 镜像的 manifest.json 与 layer tar 就是 Image Spec;docker pull 走的 /v2/ 接口是 Distribution Spec;runc 读 config.json 起容器就是 Runtime Spec。OCI 不是空话,是这三样东西的合同。
p.55

Entornos de ejecución de contenedores · 容器运行时环境

▸ 原页截图 p.55(页脚印 59) 原讲义第 55 页

Entornos de ejecución de contenedores

容器的运行环境(container runtime)。

Proporcionan operaciones básicas para ejecutar contenedores e interaccionar con ellos, de forma consistente.

它们以一致的方式,提供运行容器并与容器交互的基础操作。

Container Runtime

容器运行时。

Imagen

镜像。

Overlay FS

Overlay 文件系统(分层叠加)。

Copy On Write

写时复制(COW)。

这一页是「运行时」的定义页,考法通常是让你把四个方块串成一条链:运行时负责执行,镜像是只读模板,OverlayFS 负责分层叠加,COW 负责「改的时候才复制」。四个词缺一,解释就不完整。
左上角孤立「1」同样是模板残留;另外 interaccionar 在西语里更常用 interactuar,原文用了前者,照抄不改。
提前埋个伏笔:OverlayFS 与 COW 正是 p.36–p.39 讲的 UnionFS 内容,也是后面「镜像 = 只读层叠、容器 = 加一个可写层」的技术底座。看到这一页就该想起 p.37 的 lowerdir / upperdir / workdir。

八、容器运行时与 Docker 架构

p.56–p.62
p.56

Docker no es el único: el estándar OCI · Docker 不是唯一:OCI 标准

▸ 原页截图 p.56(页脚印 60) 原讲义第 56 页

Docker no es el único: el estándar OCI

Docker 并不是唯一:OCI 标准。

Al principio cada motor de contenedores tenía su propio formato de imagen.

起初,每个容器引擎都有自己的镜像格式。

En 2015 se creó la Open Container Initiative, que estandarizó tanto el formato de imagen como el tiempo de ejecución.

2015 年成立了 Open Container Initiative,把镜像格式与运行环境(runtime)都做了标准化。

Hoy una imagen construida con Docker se ejecuta en cualquier motor conforme.

今天,用 Docker 构建的镜像可以在任何符合标准的引擎上运行。

containerd — El motor que usa Docker por debajo — y el que usa Kubernetes directamente.

containerd —— Docker 底层使用的引擎,也是 Kubernetes 直接使用的引擎。

CRI-O — Motor ligero pensado solo para Kubernetes.

CRI-O —— 专为 Kubernetes 设计的轻量级引擎。

Podman — Compatible con la CLI de Docker, sin demonio y con soporte rootless.

Podman —— 兼容 Docker 命令行,无守护进程,支持 rootless(免 root)。

Por qué os importa: en la Sesión 4 veréis que los nodos de vuestro clúster de Kubernetes NO usan Docker: usan containerd.

为什么这对你们重要:第 4 课会看到,你们 Kubernetes 集群的节点不用 Docker,而是用 containerd。

Vuestras imágenes funcionan igual porque ambos cumplen el mismo estándar.

你们的镜像照样能用,因为两者遵循同一个标准。

三张卡片必须能「一句话定位」:containerd=Docker 底层 + K8s 默认;CRI-O=只为 K8s;Podman=无 daemon + rootless。选择题常把「CRI-O 支持 rootless」和「Podman 专为 K8s」交叉设陷,别记串。
原文 el tiempo de ejecución 按语境应是 el entorno de ejecución(运行环境);runtime 一词直译成「执行时间」会闹笑话,照抄原文但理解要按「运行环境」。
本课程最实用的一条:K8s 1.24 起移除了 dockershim,节点默认走 containerd。所以「会 docker 命令」不等于「懂 K8s 运行时」,但镜像、Dockerfile、registry 这些技能 100% 可迁移——因为 OCI 标准在中间兜着。
p.57

runc · 最底层的运行时

▸ 原页截图 p.57(页脚印 61) 原讲义第 57 页

runc

runc。

[✓] CLI, sencillo

[✓] 命令行接口,简单。

Basado en libcontainer (entorno abierto de Docker)

基于 libcontainer(Docker 开源的运行环境)。

[X] No expone API, descargas, ..

[X] 不对外提供 API,也不负责下载镜像等。

[X] No expone un daemon

[X] 不提供守护进程。

Puede integrarse con el Linux service manager, systemd.

可以与 Linux 的服务管理器 systemd 集成。

Implementa capas bajas

只实现底层功能。

runc 的定位是「只干一件事」:给它一个符合 OCI Runtime Spec 的 bundle(config.json + rootfs),它就把进程按 namespaces/cgroups 起起来。它不管镜像、不管网络、不管 API——所以上面才需要 containerd 这种「总管」。
原文用 [✓] / [X] 手写标记「支持 / 不支持」,且两条 [X] 后面跟的是「没有的能力」(不暴露 API、无 daemon),不是缺点列表,别读反。
一句话链路:docker CLI → dockerd → containerd → containerd-shim → runc → 进程。runc 执行完 runc create/start 就退出,真正守着容器的是 shim——这就是为什么 runc 自己不需要 daemon。
p.58

containerd · 容器总管

▸ 原页截图 p.58(页脚印 62) 原讲义第 58 页

containerd

containerd。

Incluye operaciones:

包含以下操作:

almacenar y transferir contenedores.

存储与传输容器(镜像)。

Ejecutar contenedores

运行容器。

asociar almacenamiento y red

关联存储与网络。

Funciona como un Daemon para runtimes

作为运行时的守护进程工作。

Docker, Kubernetes IBM (IKS), Google Cloud (GKE)...

被 Docker、IBM Kubernetes(IKS)、Google Cloud(GKE)等采用……

Cloud Native Computing Foundation (CNCF) graduated

是 CNCF 的「毕业」项目。

OCI runtime + image spec: usa runc en capas bajas

遵循 OCI 运行时与镜像规范:底层调用 runc。

Plugins para Kubernetes Component Runtime Interface (CRI)

提供 Kubernetes 容器运行时接口(CRI)插件。

Compatible con herramientas para CRI: crictl and nerdctl

兼容 CRI 工具:crictl 与 nerdctl。

https://www.docker.com/blog/containerd-vs-docker/

参考链接:https://www.docker.com/blog/containerd-vs-docker/。

containerd 的四大能力记成「存、跑、挂、管」:store(镜像)、run(容器)、attach(存储/网络)、daemon(对外服务)。考试若问「containerd 和 runc 的关系」,答「containerd 管生命周期、调 runc 起进程」即满分。
原文 Kubernetes IBM (IKS) 语序别扭,规范写法是 IBM Kubernetes Service (IKS);crictl and nerdctl 混入英文 and,西语应为 y。均照抄。
CNCF graduated 是什么含金量:毕业项目意味着「已被生产环境大规模验证」,同级别的还有 Kubernetes、Prometheus、Envoy。写简历时把 containerd 归到这一档,比写「熟悉 Docker」更有分量。
p.59

docker · 不只是运行时

▸ 原页截图 p.59(页脚印 66) 原讲义第 59 页

docker

docker。

Es más que un entorno de ejecución de contenedores.

它不只是一个容器运行时。

Plataforma para desarrollo y gestión

它是一个开发与管理平台。

Operaciones sobre: imagen, contenedor, runtime

操作对象包括:镜像、容器、运行时。

Originalmente usaba LXC, posteriormente desarrolló su propio entorno libcontainer, que hoy es open source y parte de runc.

最初使用 LXC,后来开发了自己的运行环境 libcontainer,它如今是开源的,并成为 runc 的一部分。

containerd también es open source y fue iniciado por Docker.

containerd 同样是开源的,也由 Docker 发起。

Implementa especificaciones OCI y proporciona herramientas:

实现 OCI 规范,并提供这些工具:

firma de imágenes de contenedores,

容器镜像签名,

gestión de registros de contenedores,

容器镜像仓库管理,

ciclo de vida, …

生命周期管理……

Se base en el Docker Engine a nivel de arquitectura.

在架构层面基于 Docker Engine。

「Docker 到底是什么」的标准答案:平台(platform),而不是单纯的 runtime。它把镜像构建(build)、分发(push/pull)、运行(run)三件事打包成一套工具链——这也是它能赢过 LXC 的原因:LXC 只有「跑」,Docker 有「造 + 传 + 跑」。
两处照抄:Operaciones sobre : imagen 冒号前多一个空格;Se base en 应为 Se basa en。另外本页印页码 66,与上一页 62 之间跳了 3 个号(物理页序仍连续)。
血统图记一遍:LXC → libcontainer → runc;Docker → containerd(2017 捐给 CNCF)。所以「Docker 被拆开了」是事实:上层是 CLI/平台,中层是 containerd,底层是 runc,三层各自独立开源。
p.60

Docker. Arquitectura · Docker 架构图

▸ 原页截图 p.60(页脚印 67) 原讲义第 60 页

Docker. Arquitectura

Docker 架构。

Client

客户端(Client):docker run / docker build / docker pull。

Docker Host

Docker 主机(Host):里面跑 Docker daemon。

Images

镜像区(图中示例:python、redis、nginx)。

Containers

容器区(由镜像启动出的运行实例)。

Registry

镜像仓库(Registry):Images、Extensions、Plugins 三栏。

Fuente: https://docs.docker.com/get-started/docker-overview/#docker-architecture

来源:https://docs.docker.com/get-started/docker-overview/#docker-architecture。

出处 p.60(讲义架构图转录)
┌─ Client ─────┐      ┌─ Docker Host ────────────────────────────┐      ┌─ Registry ──────┐
│ docker run   │─────▶│                ┌─ Images ─┐  ┌ Containers┐│      │ Images          │
│ docker build │─────▶│  Docker        │  python  │─▶│           ││◀╌╌╌╌ │  nginx / redis  │
│ docker pull  │─────▶│  daemon        │  redis   │  │           ││      │  python / ubuntu│
└──────────────┘      │                │  nginx   │  └───────────┘│╌╌╌╌╌▶│ Extensions      │
                      └────────────────└──────────┘───────────────┘      │ Plugins         │
                                                                          └─────────────────┘
   ──▶ 本地调用(socket)        ╌╌▶ 网络拉取 / 推送(HTTPS)
图的读法就一句话:Client 发命令 → daemon 干活 → 镜像从 Registry 拉、容器从镜像起。注意 docker build 的箭头也进 daemon,说明构建同样由守护进程完成,不是客户端本地算的。
虚线 = 网络,实线 = 本机 socket:Client 与 daemon 之间走 /var/run/docker.sock;daemon 与 Registry 之间走 HTTPS。这也解释了「为什么把 socket 挂进容器等于给它 root」——p.61 马上讲。
原页文本层几乎为空(只有标题和来源),正文全在图里,本页内容按截图转录;页脚重复出现「Fuente:」字样,属模板残留,照抄不改。
p.61

La arquitectura de Docker · Docker 架构:客户端、守护进程与仓库

▸ 原页截图 p.61(页脚印 68) 原讲义第 61 页

La arquitectura de Docker

Docker 的架构。

Cliente, demonio y registro

客户端、守护进程与镜像仓库。

El comando "docker" que escribís es solo un cliente: no ejecuta nada.

你敲下的 docker 命令只是一个客户端:它本身什么都不执行。

Envía la petición a un demonio (dockerd) que corre en segundo plano y es quien realmente gestiona imágenes, contenedores, redes y volúmenes.

它把请求发给后台运行的守护进程(dockerd),真正管理镜像、容器、网络和卷的是这个守护进程。

Cliente — docker — El comando que escribís

客户端 —— docker —— 你敲的那个命令。

Demonio — dockerd — Gestiona imágenes, contenedores y redes. Habla con el kernel.

守护进程 —— dockerd —— 管理镜像、容器与网络,并与内核对话。

Registro — Docker Hub — De donde se descargan y a donde se publican imágenes

仓库 —— Docker Hub —— 镜像从这里下载,也发布到这里。

Por eso hace falta pertenecer al grupo "docker": para poder hablar con el socket del demonio sin usar sudo en cada comando.

所以才需要加入 docker 用户组:这样不必每条命令都加 sudo 就能与守护进程的 socket 通信。

Y por eso es un asunto de seguridad: quien puede hablar con ese socket puede arrancar un contenedor privilegiado y, con él, hacer cualquier cosa en la máquina.

也正因如此它是个安全问题:能访问该 socket 的人,就能启动一个特权容器,并借它在机器上为所欲为。

Pertenecer al grupo "docker" equivale, en la práctica, a ser root.

加入 docker 组,实际上等同于拿到了 root。

这是安全题的高频答案:docker 组 ≈ root。理由链要背全——socket 可写 → 能建容器 → 能挂宿主根目录(-v /:/host)→ 能改宿主文件。考试若只写「docker 需要 sudo」是不够的,必须点到 socket 权限。
原文用了 voseo(escribís)又与前面 os importa 的西班牙本土用法混在一起,属教师口音混用,不影响理解;quien realmente gestiona 中的 quien 在此可加不加重音,照抄。
三栏记忆法:Cliente=嘴(只说不动手)、Daemon=手(真正干活)、Registry=仓库(货架)。再加一句「socket 是嘴和手之间的神经」——把 /var/run/docker.sock 挂进容器,等于把这根神经递给别人。
p.62

El ciclo de vida de un contenedor · 容器生命周期与命令

▸ 原页截图 p.62(页脚印 69) 原讲义第 62 页

El ciclo de vida de un contenedor

容器的生命周期。

Y los comandos que lo recorren

以及走完这条链的命令。

created — docker create

已创建(created)—— docker create。

running — docker start / docker run

运行中(running)—— docker start 或 docker run。

paused / stopped — docker stop

暂停 / 已停止(paused / stopped)—— docker stop。

removed — docker rm

已删除(removed)—— docker rm。

docker run [OPCIONES] IMAGEN [COMANDO] [ARGUMENTOS]

命令语法:docker run [OPCIONES] IMAGEN [COMANDO] [ARGUMENTOS]。

Es un atajo: equivale a docker pull (si hace falta) + docker create + docker start.

它是个快捷方式:等价于 docker pull(若本地没有)+ docker create + docker start。

-d — En segundo plano (detached).

-d —— 后台运行(detached)。

-it — Interactivo con terminal. Es lo que se usa para entrar en un contenedor.

-it —— 交互式并分配终端,就是「进入容器」时用的那个。

--rm — Borra el contenedor automáticamente al terminar.

--rm —— 容器结束后自动删除。

--name — Le da un nombre, en vez del identificador aleatorio.

--name —— 给容器起名字,替代随机 ID。

出处 p.62(生命周期与选项表转录)
docker create ──▶ created ──docker start──▶ running ──docker stop──▶ stopped
                        ▲                    │
                        └──docker run────────┘   (run = pull + create + start)
                                             │
                                       docker rm ──▶ removed
「docker run 做了什么」是必考题:pull(若无)+ create + start,三步合一。另一个常考陷阱:docker stop 之后容器还在(stopped),只有 docker rm 才真正消失——所以磁盘会被「停止的容器」塞满。
-it 拆开看:-i 保持 STDIN 打开,-t 分配伪终端。少了 -i 你就没法输入,少了 -t 提示符就不正常——背成「i 管输入,t 管终端」。
原文把 paused / stopped 并成一个状态框,实际 paused 要由 docker pause 产生,docker stop 只到 stopped;图上简化了,别当成一个命令能出两种状态。

九、Dockerfile 指令详解

p.63–p.70
p.63

Dockerfile · 什么是 Dockerfile

▸ 原页截图 p.63(页脚印 70) 原讲义第 63 页

Un Dockerfile es un documento de texto que contiene todos los comandos necesarios que un usuario podría ejecutar para ensamblar una imagen.

Dockerfile 是一个文本文件,包含用户为组装一个镜像可能需要执行的全部命令。

Estos incluyen:

其中包括:

1. Copia del código fuente a la imagen (los contenedores se ejecutan en entornos aislados por seguridad y no se comparte información, a priori).

1. 把源代码复制进镜像(容器出于安全运行在隔离环境中,原则上不与外界共享信息)。

2. Instalación de las librerías necesarias (tanto para compilar como para ejecutar la aplicación).

2. 安装所需的库(既包括编译用的,也包括运行应用用的)。

3. Exposición de un puerto para acceder a la aplicación (de nuevo los contenedores son entornos aislados y hay que habilitar su acceso si se necesita).

3. 暴露一个端口以便访问应用(容器是隔离环境,需要访问就得显式开放)。

4. Comando para ejecutar la aplicación.

4. 启动应用的命令。

Docker construye las imágenes leyendo los comandos de forma descendente de un Dockerfile.

Docker 自上而下读取 Dockerfile 中的命令来构建镜像。

Por tanto, antes de ejecutar la aplicación deben de estar instaladas las librerías necesarias!

因此,在运行应用之前,必须先装好所需的库!

Dockerfile 的四个必备要素就是「代码、依赖、端口、启动命令」。写 Dockerfile 时按这个顺序自查:COPY 源码了吗?装依赖了吗?EXPOSE 了吗?CMD 写了吗?四问答完,镜像基本能跑。
原文 deben de estar instaladas 用了 deber de(表推测),此处是「必须」,规范应为 deben estar instaladas;照抄不改。句末感叹号用英文 !,西语规范应为首尾 ¡…!。
为什么顺序这么重要:Docker 逐层构建并缓存,依赖装在源码复制之前,改代码时才不会重装依赖。这一条在 p.66 的 RUN 缓存段和 p.100 的 CACHED 实验里会再次出现,是本章的「省钱主线」。
p.64

Dockerfile comando FROM · FROM:指定基础镜像

▸ 原页截图 p.64(页脚印 71) 原讲义第 64 页

Dockerfile comando FROM

Dockerfile 指令:FROM。

FROM <imagen>

语法:FROM <imagen>。

Establece la imagen base para las instrucciones posteriores (se pueden crear imágenes sobre imágenes ya creadas).

为后续指令设定基础镜像(可以在已有镜像之上再建镜像)。

Ejemplo de imagen base de Python: FROM Python:3.7

Python 基础镜像示例:FROM python:3.7。

Es un comando obligatorio y tiene que ser la primera instrucción de cada Dockerfile.

它是必填指令,并且必须是每个 Dockerfile 的第一条指令。

Se puede partir de imágenes mínimas como Alpine (un mínimo Linux que ocupa 5 MB), hasta imágenes que contengan el entorno de ejecución ya instalado, como Java o Python.

既可以从 Alpine 这种极简镜像起步(一个只有 5 MB 的迷你 Linux),也可以从已装好运行环境的镜像起步,比如 Java 或 Python。

Consejo: buscar imágenes con el comando docker search en Docker Hub.

小贴士:在 Docker Hub 上用 docker search 搜索镜像。

三个考点一次记牢:①FROM 必须且第一(唯一例外:ARG 可以写在 FROM 之前);②基础镜像决定体积与攻击面——Alpine 5 MB vs ubuntu 70+ MB;③镜像可以叠镜像,这就是分层的来源。
示例里 FROM Python:3.7 的 Python 不该大写(镜像名全小写),正确是 python:3.7;另外 3.7 已停止维护,实际应选受支持的版本。原文照抄。
Alpine 的坑要提前说:它用 musl libc 而不是 glibc,某些二进制(尤其 Python 的 C 扩展)会装不上。生产里常见 -slim 版(Debian 底 + 精简)更好用——Alpine 不是无脑首选。
p.65

Dockerfile comando COPY/ADD · COPY 与 ADD:往镜像里放文件

▸ 原页截图 p.65(页脚印 72) 原讲义第 65 页

Dockerfile comando COPY/ADD

Dockerfile 指令:COPY / ADD。

COPY [--chown=<user>:<group>] <src>... <dest>

语法:COPY [--chown=<user>:<group>] <src>... <dest>。

La instrucción COPY copia nuevos ficheros o directorios de <src> y los añade al sistema de archivos del contenedor en la ruta <dest>.

COPY 把 <src> 处的新文件或目录复制到容器文件系统中的 <dest> 路径。

Ejemplo: COPY test.txt relativeDir/

示例:COPY test.txt relativeDir/。

Se puede emplear con expresiones regulares.

可以使用(通配)表达式。

Ejemplo: copiando todos los ficheros que empiecen por hom: COPY hom* /mydir/

示例:复制所有以 hom 开头的文件:COPY hom* /mydir/。

Es un comando opcional, aunque la mayor parte de nuestras aplicaciones necesitarán un código fuente que copiar.

它是可选指令,不过我们大多数应用都需要复制源代码进去。

La etiqueta ADD es similar a COPY, pero además permite copiar contenidos de una URL y auto-extrae ficheros .tar.

ADD 与 COPY 类似,但额外允许从 URL 复制内容,并会自动解包 .tar 文件。

COPY vs ADD 的送分题:能用 COPY 就别用 ADD。理由两条:ADD 从 URL 拿的文件不会解包、也不进构建缓存,行为不可预测;并且 ADD 会自动解包 tar,容易把不该铺开的文件铺开。生产规范几乎都写「prefer COPY」。
原文说 expresiones regulares(正则),实际 COPY 用的是 Go 的 filepath.Match 通配符(*、?、[]),不是正则;auto-extrae 规范应连写 autoextrae。均照抄原文。
--chown 是实战必备:不加它,复制进去的文件属主是 root,非 root 用户跑应用就会「无权限写」。加了 --chown=1000:1000(p.99 的 USER 1000:1000 正是配套)就不会踩坑。
p.66

Dockerfile comando RUN · RUN:构建时执行命令

▸ 原页截图 p.66(页脚印 73) 原讲义第 66 页

Dockerfile comando RUN

Dockerfile 指令:RUN。

RUN <comando>

语法:RUN <comando>。

La instrucción RUN ejecutará un comando sobre la terminal del SO de la imagen y confirmará los resultados.

RUN 会在镜像操作系统的终端上执行一条命令,并把结果固化(提交)下来。

Normalmente se utiliza para instalar librerías y entornos necesarios para la compilación. Es un comando opcional.

通常用来安装编译所需的库和环境。它是可选指令。

Ejemplo para instalar librerías en Python: RUN pip install --trusted-host pypi.python.org -r requirements.txt

Python 安装依赖的示例:RUN pip install --trusted-host pypi.python.org -r requirements.txt。

Los comandos se ejecutan en capas y hay una cache.

命令按层执行,并且存在缓存。

Si en una nueva compilación esta capa no ha cambiado, se aprovecha la capa y no se genera de nuevo, ahorrando tiempo (ya veréis que a veces los contenedores son lentos para compilar).

如果新一次构建中这一层没变,就直接复用该层、不再重新生成,从而节省时间(你们会看到,容器有时构建很慢)。

出处 p.66(指令语法与示例转录)
# 安装 Python 依赖(构建时执行)
RUN pip install --trusted-host pypi.python.org -r requirements.txt

# 层缓存示意:内容不变 → 直接复用
Step 5/8 : RUN pip install -r requirements.txt
 ---> Using cache
 ---> 3f2a9c1b7d40
RUN 的两个必考属性:①构建时执行(不是运行时,运行时用 CMD / ENTRYPOINT);②每条 RUN 生成一层。所以装包要合并成一条 RUN apt-get update && apt-get install -y … && rm -rf /var/lib/apt/lists/*,否则层数暴涨、镜像变胖。
示例里的 --trusted-host pypi.python.org 是老版本 pip 在 TLS 证书缺失时的绕过写法,现代镜像里不该再用(等于关掉校验);原文照抄,但实操请去掉。
缓存怎么破:只要 RUN 的命令字符串或它依赖的前一层变了,缓存就失效。所以 COPY requirements.txt . 要写在 COPY . . 之前——改代码不会让依赖重装,这是 p.100 实验的核心结论。
p.67

Dockerfile comando EXPOSE · EXPOSE:声明端口

▸ 原页截图 p.67(页脚印 74) 原讲义第 67 页

Dockerfile comando EXPOSE

Dockerfile 指令:EXPOSE。

EXPOSE <port> [<port>/<protocol>...]

语法:EXPOSE <port> [<port>/<protocol>...]。

La instrucción opcional EXPOSE informa a Docker que el contenedor escucha en los puertos de red (TCP o UDP) especificados en tiempo de ejecución.

可选指令 EXPOSE 告知 Docker:该容器在运行时监听指定的网络端口(TCP 或 UDP)。

Ejemplo para el puerto TCP 80: EXPOSE 80/tcp EXPOSE 80

TCP 80 端口示例:EXPOSE 80/tcp,或简写 EXPOSE 80。

La instrucción EXPOSE no publica al exterior el puerto.

EXPOSE 并不把端口发布到外部。

Funciona como un tipo de documentación entre la persona que construye la imagen y la persona que ejecuta el contenedor, para que ésta sepa qué puertos están destinados a ser publicados.

它更像一种「文档」:告诉运行容器的人,哪些端口是设计上应当对外发布的。

A la hora de ejecutar el contenedor se puede realizar las redirección de puertos con el flag –p:

运行容器时,可以用 -p 参数做端口重定向:

docker run -p 9000:80

docker run -p 9000:80。

Puerto dentro del contenedor / Puerto expuesto fuera de Docker

容器内部的端口 / 暴露到 Docker 外部的端口(图注,冒号左内右外)。

出处 p.67(端口映射示意转录)
docker run -p 9000:80 imagen
                 │    │
     宿主机端口 ◀─┘    └─▶ 容器内端口
     (fuera de Docker)   (dentro del contenedor)
最高频陷阱:EXPOSE 不等于发布。EXPOSE 只是元数据(docker inspect 里能看到),真正对外要靠 -p 宿主机:容器 或 -P 随机映射。考试里「EXPOSE 80 后浏览器能访问吗」——不能,除非 run 时加了 -p。
原文 el flag –p 用的是 en dash(–)而不是连字符(-),复制到终端会报错;另外 se puede realizar las redirección 数量不一致,规范应为 realizar la redirección。均照抄。
方向别搞反:-p 9000:80 = 宿主 9000 → 容器 80。写反了就变成「访问 80 却进了 9000」。记法:左宿主、右容器,和你 ssh 的 -L 本地:远端 一个逻辑。
p.68

Dockerfile comando CMD · CMD:默认启动命令

▸ 原页截图 p.68(页脚印 75) 原讲义第 68 页

Dockerfile comando CMD

Dockerfile 指令:CMD。

CMD ["executable","param1","param2"]

JSON 数组形式:CMD ["executable","param1","param2"](exec form,推荐)。

CMD executable param1 param2

Shell 形式:CMD executable param1 param2(会经由 /bin/sh -c 执行)。

La instrucción CMD establece el comando por defecto y sus parámetros que se ejecutarán cuando se ejecute el contenedor.

CMD 设定容器启动时默认执行的命令及其参数。

Hay varias formas:

有多种写法:

Ejemplo: CMD ["/usr/bin/wc","--help"]

示例:CMD ["/usr/bin/wc","--help"]。

Se puede utilizar junto con el comando ENTRYPOINT.

可以与 ENTRYPOINT 配合使用。

ENTRYPOINT se ejecuta cuando el contenedor está iniciado (normalmente se utiliza para ejecutar/realizar aspectos de configuración).

ENTRYPOINT 在容器启动时执行(通常用于执行配置类的动作)。

CMD 三条铁律:①只有最后一条 CMD 生效;②运行时会被覆盖——docker run imagen ls 里的 ls 会顶掉 CMD;③构建时不执行(RUN 才在构建时跑)。这三条几乎每年都考。
原文对 ENTRYPOINT 的解释偏口语且不准确:ENTRYPOINT 不是「用于配置」,而是固定入口——它不会被 docker run 后面的参数覆盖,那些参数会变成它的附加参数。照抄原文,但理解按后者。
CMD vs ENTRYPOINT 一句话:ENTRYPOINT 是「写死的主程序」,CMD 是「可被替换的默认参数」。最佳实践:ENTRYPOINT ["python"] + CMD ["app.py"],这样 docker run imagen other.py 就能换脚本。
p.69

Dockerfile otros comandos · WORKDIR 与 ENV

▸ 原页截图 p.69(页脚印 76) 原讲义第 69 页

Dockerfile otros comandos

Dockerfile 其他指令。

La instrucción WORKDIR cambia el directorio de trabajo dentro del contenedor.

WORKDIR 切换容器内的工作目录。

Por defecto es el directorio raíz (/).

默认是根目录(/)。

Ejemplo: WORKDIR /uma

示例:WORKDIR /uma。

La instrucción ENV crea una variable de entorno.

ENV 创建环境变量。

Las variables de entorno permiten enviarle información a los contenedores antes de su ejecución.

环境变量让你在容器运行之前就把信息传进去。

Esta información se puede leer en el código fuente de la aplicación y puede cambiar en cada ejecución.

这些信息可以在应用源码中读取,并且每次运行都可以不同。

Ejemplo para definir el nombre de una aplicación: ENV NAME UMA

定义应用名称的示例:ENV NAME UMA。

两个高频细节:①WORKDIR 会创建目录(不存在就建),且对后续 RUN/CMD/COPY 都生效;②ENV 之后每一层都能读到,且会被写进镜像——所以密码、token 绝不能写 ENV(p.97 会专门讲)。
原文 ENV 与 NAME UMA 被排版拆成两行,实际是一条指令 ENV NAME UMA;现代写法更推荐 ENV NAME=UMA(带等号),旧式空格写法已不推荐。照抄原文。
WORKDIR 比 cd 强在哪:RUN cd /app 只在那一层有效,下一层又回到 /;WORKDIR 是持久状态,后续所有指令都在该目录下执行。这也是新手最常踩的「为什么我的 COPY 放错地方」。
p.70

Ejemplo Dockerfile · 完整示例:Python Flask 应用

▸ 原页截图 p.70(页脚印 77) 原讲义第 70 页

Ejemplo Dockerfile

Dockerfile 示例。

Dockerfile para una aplicación web con Python Flask

一个 Python Flask Web 应用的 Dockerfile。

# Use an official Python runtime as a parent image

# 使用官方 Python 运行时作为父镜像。

FROM python:3.7-slim

FROM python:3.7-slim——基于精简版 Python 3.7。

# Set the working directory to /app

# 把工作目录设为 /app。

WORKDIR /app

WORKDIR /app。

# Copy the current directory contents into the container at /app

# 把当前目录内容复制到容器的 /app。

ADD . /app

ADD . /app——把构建上下文整个复制进去。

# Install any needed packages specified in requirements.txt

# 安装 requirements.txt 中指定的依赖。

RUN pip install --trusted-host pypi.python.org -r requirements.txt

RUN pip install --trusted-host pypi.python.org -r requirements.txt。

# Make port 80 available to the world outside this container

# 让 80 端口可被容器外部访问(注释这么说,实际只是声明)。

EXPOSE 80

EXPOSE 80——声明监听 80。

# Define environment variable

# 定义环境变量。

ENV NAME World

ENV NAME World。

# Run app.py when the container launches

# 容器启动时运行 app.py。

CMD ["python", "app.py"]

CMD ["python", "app.py"]。

https://docs.docker.com/engine/reference/builder/

官方参考:https://docs.docker.com/engine/reference/builder/。

出处 p.70(完整 Dockerfile 转录)
# Use an official Python runtime as a parent image
FROM python:3.7-slim
# Set the working directory to /app
WORKDIR /app
# Copy the current directory contents into the container at /app
ADD . /app
# Install any needed packages specified in requirements.txt
RUN pip install --trusted-host pypi.python.org -r requirements.txt
# Make port 80 available to the world outside this container
EXPOSE 80
# Define environment variable
ENV NAME World
# Run app.py when the container launches
CMD ["python", "app.py"]
这 7 条指令就是「最小可用 Dockerfile」的标准骨架:FROM → WORKDIR → COPY/ADD → RUN → EXPOSE → ENV → CMD。考试若要求手写一个 Dockerfile,按这个顺序默写即可,顺序错(尤其 RUN 在 COPY 之前)会被扣分。
两处原文问题:①第 10 行注释说「Make port 80 available to the world outside」——如 p.67 所述 EXPOSE 不对外发布,注释有误导;②用了 ADD . /app,按最佳实践应改为 COPY . /app。均照抄不改。
这段代码的历史梗:它出自 Docker 官方「Get Started」教程,几乎是所有人写的第一份 Dockerfile。但它把依赖安装放在 ADD . /app 之后,改一行代码就会触发 pip 重装——正确做法是先 COPY requirements.txt . 再 RUN pip install。

十、Docker 组件与桌面工具

p.71–p.76
p.71

Docker. Componentes y Herramientas · Docker 组件与工具

▸ 原页截图 p.71(页脚印 78) 原讲义第 71 页

Docker. Componentes y Herramientas

Docker 组件与工具。

Cliente Docker

Docker 客户端。

CLI, en local o en remoto, envia comandos hacia el Docker daemon

命令行工具,可在本地或远程,向 Docker 守护进程发送命令。

Interfaces con el daemon: Rest API, sockets, interfaz de red.

与守护进程的接口:REST API、socket、网络接口。

Docker Compose

Docker Compose。

Define servicios y dependencias en manifiestos YAML, para ejecutarlos

用 YAML 清单定义服务与依赖,然后统一执行。

Docker Host

Docker 主机。

Sistema donde se ejecuta dockerd (el daemon)

运行 dockerd(守护进程)的系统。

dockerd construye, ejecuta y distribuye contenedores.

dockerd 负责构建、运行与分发容器。

Gestiona objetos docker (imágenes, contenedores, redes, volumenes)

管理 Docker 对象(镜像、容器、网络、卷)。

Puede colaborar con otros daemons formando un cluster distribuido.

可与其他守护进程协作,组成分布式集群。

Usa tráfico tanto inseguro y como seguro con certificado TLS y claves.

既使用不加密流量,也使用带 TLS 证书与密钥的加密流量。

Gestiona un repositorio local de imágenes

管理本地镜像仓库。

Docker Hub es un repositorio externo (https://hub.docker.com/)

Docker Hub 是外部仓库(https://hub.docker.com/)。

四类组件记成「端、编排、宿主、仓库」:Client(CLI)→ Compose(多容器编排)→ Host(dockerd)→ Registry(本地 + Docker Hub)。考试常问「Compose 属于客户端还是服务端」——它是客户端工具,把 YAML 翻成 API 调用发给 daemon。
三处拼写照抄:envia 应为 envía;volumenes 应为 volúmenes;tanto inseguro y como seguro 句式杂糅,规范为 tanto inseguro como seguro。
2375 / 2376 这两个端口要认识:2375 是明文(inseguro),2376 是 TLS(seguro)。把 2375 暴露到公网等于把 root 送人——这正是原文那句「tráfico inseguro」的现实含义。
p.72

Docker. Herramientas de instalación y configuración · Docker Desktop

▸ 原页截图 p.72(页脚印 79) 原讲义第 72 页

Docker. Herramientas de instalación y configuración

Docker 安装与配置工具。

Docker Desktop

Docker Desktop。

Gestor de instalación: Linux, Windows, MAC.

安装管理器:支持 Linux、Windows、Mac。

Instala: Docker Engine, CLI client, Docker Compose, Kubernetes

安装内容:Docker Engine、CLI 客户端、Docker Compose、Kubernetes。

Funciones:

功能:

Configuración de arranque

启动配置(开机自启、启动参数)。

Gestión de límites de recursos

资源限额管理(CPU、内存、磁盘)。

Mapeo puntos de montaje de disco a contenedores

把磁盘挂载点映射到容器。

Configuración de Red y DNS

网络与 DNS 配置。

Proxy para descarga de imágenes de contenedores

用于拉取容器镜像的代理。

Docker Desktop 的定位是「一键装全家桶」:Engine + CLI + Compose + 单节点 Kubernetes。考试若问「Windows 上怎么跑 Linux 容器」,答案链是:Desktop → WSL2 后端 → 轻量 VM 里的 Linux 内核——这也呼应 p.51「容器不能跨内核」。
原文 MAC 应为 Mac(不是缩写,不该全大写);Mapeo puntos de montaje 缺介词,规范为 Mapeo de puntos de montaje。照抄不改。
商业授权坑:Docker Desktop 对大企业(250 人以上或年收入 1000 万美元以上)收费,个人/教育免费。公司里更常见的是直接装 Docker Engine(p.85 会对比 Engine 与 Desktop 的 8 行差异)。
p.73

Podman · 无守护进程的容器引擎

▸ 原页截图 p.73(页脚印 80) 原讲义第 73 页

Podman

Podman。

Container engine:

容器引擎:

Desarrollo, gestion y ejecución de contenedores OCI.

面向 OCI 容器的开发、管理与运行。

Sin demonio

无守护进程(daemonless)。

Usa libpod para gestionar pods, contenedores, imagenes y volumenes.

用 libpod 管理 Pod、容器、镜像与卷。

Usa conmon para monitorizar contenedores

用 conmon 监控容器。

Servicio API REST: bajo petición de aplicaciones remotas

REST API 服务:按远程应用的请求提供服务。

Instala: Docker Engine, CLI client, Docker Compose, Kubernetes

安装内容:Docker Engine、CLI 客户端、Docker Compose、Kubernetes。

Imita el CLI de docker (podman-tui)

模仿 Docker 的命令行(podman-tui)。

También tienne un GUI (Podman Desktop)

也有图形界面(Podman Desktop)。

Podman 的考点集中在「三无一有」:无 daemon、无 root 也能跑(rootless)、无需改动就能照抄 docker 命令(alias docker=podman);有 pod——它原生支持 Kubernetes 的 Pod 概念。会话 4 讲 K8s 时会反复回到这点。
原文两处硬伤,照抄不改:① tienne 应为 tiene;gestion / imagenes / volumenes 均漏写重音(gestión / imágenes / volúmenes)。② Instala: Docker Engine, CLI client, Docker Compose, Kubernetes 这一行是从上一页 Docker Desktop 整段复制粘贴的事故——Podman 恰恰不装 Docker Engine,也不装 Docker Compose,Kubernetes 只是通过 pod 概念兼容。
conmon 是什么?一个极小的「容器监视器」进程,每个容器配一个,负责收集日志、记录退出码、在容器主进程死后回收资源。没有 daemon,就得靠它来「看着」容器——这是 Podman 无守护架构的关键零件。
p.74

CRI-O · 面向 Kubernetes 的极简运行时

▸ 原页截图 p.74(页脚印 81) 原讲义第 74 页

CRI-O

CRI-O。

Implementación minimalista del CRI

CRI(容器运行时接口)的极简实现。

Orientado a Kubernetes

面向 Kubernetes。

Implementa el Container Network Interface (CNI)

实现 CNI(容器网络接口)。

usa runc

使用 runc 作为底层运行时。

compatible con CRI CLIs como crictl y nerdctl

兼容 crictl、nerdctl 这类 CRI 命令行工具。

CRI-O 的定位一句话:只服务 Kubernetes,别的什么都不干。它是 CRI 的「薄壳」——上接 kubelet 的 CRI 调用,下用 runc 起容器、用 CNI 配网络。考试若问「K8s 节点能不能不用 Docker」,标准答案就是 containerd 或 CRI-O。
原文 CRI CLIs 是英文复数缩写,西语行文里直接借用;usa runc 句首小写,属项目符号未大写,照抄不改。
四个名字别混:CRI = 接口规范(K8s 定义的插座);CRI-O = 该接口的一个实现(插座上的一个插头);CNI = 网络接口规范;runc = 真正 fork 出容器进程的底层工具。口诀:接口管标准,实现管落地,runc 管生娃。
p.75

Otros entornos · 其他容器环境:LXC 与 Kata

▸ 原页截图 p.75(页脚印 82) 原讲义第 75 页

Otros entornos

其他环境。

Distintos enfoques de densidad de integracion, vs seguridad y aislamiento.

在集成密度与安全隔离之间采取不同的取舍取向。

LXC

LXC。

Ofrece Full system containers

提供「完整系统容器」(整机式容器)。

Comparten kernel pero se asemejan a máquinas virtuales.

共享内核,但使用体验接近虚拟机。

Contenedores Kata

Kata 容器。

Se basa en maquinas virtuales ligeras semejantes a contenedores

基于类似容器的轻量级虚拟机。

Utilizan kernels dedicados para conseguir aislamiento y seguridad sin perder rendimiento.

使用独立内核,在不损失性能的前提下获得隔离与安全。

Soporta contenedores UCI y el Kubernetes CRI.

支持 UCI 容器与 Kubernetes CRI。

…

……(原文以省略号收尾,表示还有其他环境未展开)

这一页是「密度 ↔ 隔离」这根滑杆的三个刻度:LXC 偏密度(共享内核、整机体验)、Docker 居中、Kata 偏隔离(每个 Pod 一个轻量 VM,独享内核)。考试喜欢问「哪个能提供最强隔离」——答案是 Kata,因为它把内核都隔离了。
原文笔误照抄不改:UCI 应为 OCI(Open Container Initiative);integracion、maquinas 漏写重音(integración / máquinas);densidad de integracion 这一搭配生硬,通常说 densidad de despliegue。
Kata 的「两全」原理:外面看是一个标准 OCI 容器(照样 runc 接口、照样 CRI),里面其实跑在一台微型 VM 上。于是你既有容器的秒级启动与编排兼容性,又有 VM 级的内核隔离——代价是每容器多几十 MB 内存。多租户公有云最爱的就是这套。
p.76

Página en blanco · 空白预留页

▸ 原页截图 p.76(页脚印 84) 原讲义第 76 页

A…..

A……(预留条目 A,正文未填)。

B…..

B……(预留条目 B,正文未填)。

这页是老师留的空模板:只有 A….. 和 B….. 两个占位符,没有实际内容。按页数守恒原则照样保留一块,方便你对照原 PDF 时不会「少一页」而怀疑漏转。考试当然不会考它,但记笔记时正好可以在这里补上你自己总结的「A:容器 vs 虚拟机 / B:运行时选型」两栏。

十一、镜像:定义、引用与注册表

p.77–p.84
p.77

1d · Imágenes · 第四节分隔页:镜像

▸ 原页截图 p.77(页脚印 85) 原讲义第 77 页

1d

第 1 部分 d 小节。

Imágenes

镜像。

Fundamentos de contenedores y Docker

容器与 Docker 基础。

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

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

分隔页也是内容:它标出课程从「怎么跑容器」切换到「跑什么」——镜像。后面 p.78–p.84 依次讲:镜像是什么 → 镜像从哪来(Registry)→ 怎么引用(nombre:tag@digest)→ 本地怎么管(images / pull / tag / rmi / save / load)。看到这种只有大标题的页,别以为是空页,它是在给你画地图。
p.78

¿Qué es una imagen de contenedor? · 什么是容器镜像?

▸ 原页截图 p.78(页脚印 86) 原讲义第 78 页

¿Qué es una imagen de contenedor?

什么是容器镜像?

Una imagen incluye código, junto con sus dependencias, empaquetado conjuntamente,

镜像包含代码及其依赖,二者被打包在一起,

y con métodos de despliegue y ejecución en distintos entornos aislados y seguros.

并附带在不同隔离、安全环境中部署与执行的方法。

Los contenedores pueden ejecutarse en bare-metal, máquinas virtuales o en cloud.

容器可以跑在裸金属、虚拟机或云上。

镜像的三要素记成「代码 + 依赖 + 元数据」:不只装程序,还装它依赖的库、环境变量、默认启动命令(CMD/ENTRYPOINT)、暴露端口(EXPOSE)。所以「在我机器上能跑」这个千古难题被消掉了——因为镜像把「我的机器」也一起打包了。
镜像不是一个大文件:它是一叠只读层(layer)加一份清单(manifest)。这就是 p.36–p.39 讲的 UnionFS/OverlayFS 的用武之地:容器启动时在最上面加一个可写层,写时复制(COW),删容器即丢该层,底下所有层原封不动,可以被成百上千个容器共享。
一句话区分:镜像 = 类(只读模板),容器 = 实例(镜像 + 一个可写层 + 一个进程)。docker run 就是「new 一个对象」。
p.79

Registros Públicos · 公共镜像注册表

▸ 原页截图 p.79(页脚印 87) 原讲义第 79 页

Registros Públicos

公共注册表。

Un registro de imágenes, es un almacén especializado para entornos de contenedores.

镜像注册表是专为容器环境服务的仓库。

Permite compartir imágenes globalmente.

它让镜像可以在全球范围内共享。

Algunos servidores populares:

一些常用服务器:

Docker Hub

Docker Hub。

GitHub Container Registry (GHCR)

GitHub 容器注册表(GHCR)。

GitLab Container Registry

GitLab 容器注册表。

Amazon Elastic Container Registry (ECR)

亚马逊弹性容器注册表(ECR)。

Azure Container Registry (ACR)

Azure 容器注册表(ACR)。

Google Artifact Registry (GAR)

Google 制品注册表(GAR)。

六个注册表按「云厂商 + 代码托管」两组记:云厂商三兄弟 ACR(Azure)、ECR(AWS)、GAR(Google,注意它已经从 Container Registry 升级为 Artifact Registry);代码托管两兄弟 GHCR(GitHub)、GitLab Registry;再加所有人之家 Docker Hub。考试常考「私有镜像放哪」——企业内一般自建 Harbor 或用云厂商的私有仓库。
原文 Un registro de imágenes, es un almacén… 主语与谓语之间多了一个逗号(西语此处不应断开),照抄不改。
pull 的默认地址:不写注册表时,Docker 自动去 docker.io。这就是为什么国内拉镜像慢时,大家会配镜像加速器(下一批 p.82 的「Registros Proxy y Mirror」正是这个原理)。
p.80

Referencias a repositorios · 镜像引用的五个组成部分

▸ 原页截图 p.80(页脚印 88) 原讲义第 80 页

Referencias a repositorios

仓库引用(镜像的完整名字怎么写)。

Parte(部分)Qué designa(指什么)Obligatoria(是否必填)
registryel servidor que almacena y sirve la imagenno
namespacela organización, el proyecto o la persona dentro de ese servidorno
repositoryel conjunto de versiones de una misma imagensí
tagel nombre de una versión concretano
resumenel sha256 del contenido exactono

registry — el servidor que almacena y sirve la imagen — no

registry —— 存放并提供镜像的服务器 —— 非必填。

namespace — la organización, el proyecto o la persona dentro de ese servidor — no

namespace —— 该服务器内的组织、项目或个人 —— 非必填。

repository — el conjunto de versiones de una misma imagen — sí

repository —— 同一镜像所有版本的集合 —— 必填。

tag — el nombre de una versión concreta — no

tag —— 某个具体版本的名字 —— 非必填。

resumen — el sha256 del contenido exacto — no

digest(摘要)—— 精确内容的 sha256 —— 非必填。

La referencia completa

完整引用。

Toda imagen se identifica con una cadena que tiene hasta cinco partes:

每个镜像都由一个最多包含五部分的字符串标识:

出处 p.80(讲义截图转录)
[registro/][espacio/]repositorio[:etiqueta][@resumen]

[registro/][espacio/]repositorio[:etiqueta][@resumen]

[注册表/][命名空间/]仓库[:标签][@摘要]

El repositorio es la unidad de verdad: library/nginx es un repositorio,

仓库才是「真相单位」:library/nginx 是一个仓库,

y dentro conviven latest, alpine, 1.29-alpine y docenas más.

其中并存着 latest、alpine、1.29-alpine 以及几十个其他标签。

Lo que llamamos «la imagen» es un elemento de ese repositorio.

我们口头说的「那个镜像」,其实只是该仓库里的一个元素。

这页是**考试送分页**:五个部分里只有 repository 是必填的,其余四个都可省略,Docker 会自动补默认值。题目爱问「nginx:1.25 的 tag 是哪一段」——冒号后面就是。还要会读 ghcr.io/mi-org/api:1.0@sha256:…:五段全齐。
原文用 espacio(空间)来指 namespace,属于直译;resumen 是 digest 的西语意译(摘要),业界更常直接说 digest。两处都照抄不改。
背法:从右往左读——@sha256(精确指纹)← :tag(版本别名)← 仓库名 ← 命名空间 ← 注册表。越往左越野鸡、越可省略。右边精确,左边宽泛。
p.81

Referencias incompletas · 不完整引用如何被自动补全

▸ 原页截图 p.81(页脚印 89) 原讲义第 81 页

Referencias incompletas

不完整引用。

Cuando hay una referencia incompleta, Docker la completa por su cuenta:

当引用不完整时,Docker 会自己把它补全:

出处 p.81(讲义截图转录)
docker pull nginx  →  docker pull docker.io/library/nginx:latest

docker pull nginx se convierte en docker pull docker.io/library/nginx:latest

docker pull nginx 会被转换成 docker pull docker.io/library/nginx:latest。

Tres cosas rellenadas sin avisar:

三处被悄悄补上:

docker.io — Docker Hub como registro por omisión.

docker.io —— 默认注册表为 Docker Hub。

library — el espacio reservado a las imágenes oficiales de Docker Hub.

library —— 留给 Docker Hub 官方镜像的命名空间。

latest — la etiqueta (tag) por omisión.

latest —— 默认标签。

Etiquetas(tag):

标签(tag):

Una etiqueta Pueden cambiar. Se pueden reasignar

标签是会变的,可以被重新指向。

latest no garantiza que sea la última versión

latest 并不保证就是最新版本。

El resumen (digest): usa checksum SHA256. Garantiza el contenido.

摘要(digest):使用 SHA256 校验和,能保证内容不被篡改。

Por seguridad, en producción se usa el digest: ginx@sha256:a1b2c3...

出于安全考虑,生产环境应使用 digest:ginx@sha256:a1b2c3...

「tag 会变,digest 不会」是本页的考试核心。生产环境写 imagen@sha256:… 叫 pin by digest,因为 tag 可以被维护者重新推送覆盖(甚至恶意覆盖),而 digest 是内容哈希,改一个字节就变。K8s 里常配 imagePullPolicy: IfNotPresent + digest 来锁定版本。
原文 ginx@sha256:a1b2c3... 漏了首字母 n,应为 nginx@sha256:…;Una etiqueta Pueden cambiar 单复数不一致(应为 Una etiqueta puede cambiar 或 Las etiquetas pueden cambiar);Etiquetas(tag) 缺空格。全部照抄不改。
为什么图省事写 latest 会翻车:今天 latest 是 1.25,明天上游推了 1.26,你重建镜像就悄悄升级了基础系统,线上炸了都找不到原因。这就是「不可复现构建」的经典事故。
p.82

Tipos de Registros · 注册表的类型:私有 / 代理镜像

▸ 原页截图 p.82(页脚印 90) 原讲义第 82 页

Tipos de Registros

注册表的类型。

Privados / Self-Hosted

私有 / 自建(Self-Hosted)。

Para uso interno.

供内部使用。

Harbor: muy seguro (CNCF-graduated)

Harbor:非常安全(CNCF 毕业项目)。

Docker Registry v2 , open source pero menos seguro

Docker Registry v2:开源,但安全性较弱。

Registros Proxy y Mirror

代理注册表与镜像站(Proxy / Mirror)。

Cachean descargas / pull de repositorios públicos

缓存对公共仓库的下载 / pull 请求。

Previenen limitaciones o bloqueos por uso excesivo

防止因过度使用而被限流或封禁。

两类注册表对应两种场景:私有解决「镜像不能外泄」,代理/镜像解决「拉不动、被限流」。Harbor 是 CNCF 毕业项目(和 containerd、Kubernetes 同级别),自带漏洞扫描、签名、RBAC、复制策略;registry:2 只是最朴素的开源实现,没有认证和 UI,别直接暴露在公网。
原文 Docker Registry v2 , open source 逗号前多一个空格;Previenen limitaciones o bloqueos por uso excesivo 建议加 de(por uso excesivo 尚可)。照抄不改。
Docker Hub 的限流梗:2020 年起匿名用户每 6 小时只能拉 100 次,登录用户 200 次——CI 流水线一多就撞墙。这就是「mirror」存在的商业理由:公司内部搭一个缓存层,所有人都从它拉。
p.83

Especificaciones de Imagen y Distribución OCI · OCI 镜像与分发规范

▸ 原页截图 p.83(页脚印 91) 原讲义第 83 页

Especificaciones de Imagen y Distribucion OCI

OCI 镜像规范与分发规范。

Image OCI:

OCI 镜像:

manifest: JSON listando layers (digests) y configuration

manifest(清单):列出各层(及其 digest)与配置的 JSON。

configuration: JSON metadata: variables, comandos, puertos, …

configuration(配置):包含变量、命令、端口等元数据的 JSON。

layers: comprimidos en tar (.tar.gz)

layers(层):以 tar 压缩包(.tar.gz)形式存放。

Distribution OCI:

OCI 分发(Distribution):

Autenticación

认证。

Búsqueda de imágenes ( manifiestos: listas de capas)

镜像检索(manifest:层的列表)。

Chequeo de capas cacheadas

检查已缓存的层。

Descarga (solamente de capas que faltan)

下载(只下载缺失的层)。

Comprobación de firmas/digest

校验签名 / digest。

Almacenamiento local

本地存储。

这页把 p.54 的三规范落到具体文件上:Image Spec = manifest + config + layers 三件套;Distribution Spec = /v2/ 那套 HTTP API(认证 → 查 manifest → 查层 → 只拉缺的层 → 验签 → 落盘)。考试问「为什么 pull 很快」,答案就在「Chequeo de capas cacheadas + 只下载缺失层」。
原文标题 Distribucion 漏重音,应为 Distribución;( manifiestos: listas de capas) 左括号后多一个空格。照抄不改。
三件套的类比:manifest = 书的目录(第几层、什么哈希);config = 书的版权页与使用说明(环境变量、默认命令、端口);layers = 每章正文(tar.gz)。目录里写的是每章的「指纹」,缺哪章补哪章——所以第二次拉同一基础镜像,几乎瞬间完成。
p.84

Herramientas. Skopeo · 不落地检查与搬运镜像

▸ 原页截图 p.84(页脚印 92) 原讲义第 84 页

Herramientas. Skopeo

工具:Skopeo。

No necesita dockerd o podman, ni hacer pull.

不需要 dockerd 或 podman,也不需要先 pull。

Chequea imágenes de un registro sin descargar capas

无需下载层就能检查注册表里的镜像。

skopeo inspect <referencia a imagen>

skopeo inspect <referencia a imagen>:查看镜像元数据。

Copia entre registros

在注册表之间复制镜像。

skopeo copy <referencia origen> <referencia destino>

skopeo copy <referencia origen> <referencia destino>:从源复制到目标。

Copia a/de tar y carpetas OCI

可复制为 / 从 tar 包与 OCI 目录复制。

Ejemplo: copia a un repositorio local ( en contenedor con imagen “registry”)

示例:复制到本地仓库(运行着 registry 镜像的容器)。

出处 p.84(讲义截图转录)
# 1) 把 Docker Hub 的 hello-world 复制到本地 5000 端口的私有 registry
skopeo copy --dest-tls-verify=false   docker://docker.io/library/hello-world:latest \
        docker://localhost:5000/ejemplos/hello-world:1.0

# 2) 列出本地 registry 里所有仓库,过滤出 ejemplos 命名空间
curl -s http://localhost:5000/v2/_catalog | python3 -m json.tool | grep ejemplos

# 3) 列出该仓库的所有标签
skopeo list-tags --tls-verify=false docker://localhost:5000/ejemplos/hello-world

# 4) 查看某个具体标签的元数据(xxx 处需换成真实 tag)
skopeo inspect --tls-verify=false docker://localhost:5000/ejemplos/hello-world:xxx
Skopeo 的考点就一句:「不落地」搬运——registry 到 registry 直接拷,中间不经过本地镜像存储,所以不需要 dockerd / podman 常驻。四个子命令按「看 / 拷 / 列 / 查」记:inspect、copy、list-tags、再 inspect 指定 tag。
原文左上角残留一个孤立数字 4(模板占位未删);示例里 :xxx 是待替换占位符;( en contenedor…) 左括号后多空格。照抄不改。
为什么都带 --tls-verify=false:本地 registry:2 默认只跑 HTTP(端口 5000),没有证书,所以必须关掉 TLS 校验。这只在本地实验用,生产环境关 TLS 校验等于把镜像供应链敞开给人塞后门。
和 docker pull 的分工:pull 是「拿下来用」,skopeo 是「隔着玻璃看、直接搬」。做镜像同步、审计、CI 里检查标签是否存在,都该用 skopeo 而不是把几个 G 的镜像拉到本地。

十二、Engine vs Desktop:装什么、怎么装

p.85–p.87
p.85

Docker Engine vs Docker Desktop · 引擎与桌面的七项对比

▸ 原页截图 p.85(页脚印 93) 原讲义第 85 页

Docker Engine vs Docker Desktop

Docker Engine 与 Docker Desktop 对比。

CaracterísticaDocker EngineDocker Desktop
Enfoque PrincipalServidores, producción y entornos CI/CD.Desarrollo local y estaciones de trabajo.
Interfaz de UsuarioSolo Línea de Comandos (CLI).Interfaz Gráfica (GUI) + CLI
Sistemas OperativosNativo en Linux.Windows, macOS y Linux.
Consumo de RecursosMuy bajo. Corre directo sobre el sistema operativoMedio-Alto. Requiere una máquina virtual ligera.
Kubernetes integradoNo (requiere instalarlo aparte).Sí, se activa con un solo clic.
Docker ComposeSe instala como un plugin separado.Viene preinstalado y listo para usar.
Licencia y Costo100% Gratis y de código abierto (Apache 2.0).Gratis para uso personal y pequeñas empresas. De pago para grandes empresas.

Enfoque Principal — Servidores, producción y entornos CI/CD. / Desarrollo local y estaciones de trabajo.

主要定位 —— 服务器、生产环境与 CI/CD。/ 本地开发与工作站。

Interfaz de Usuario — Solo Línea de Comandos (CLI). / Interfaz Gráfica (GUI) + CLI

用户界面 —— 仅命令行(CLI)。/ 图形界面(GUI)+ CLI。

Sistemas Operativos — Nativo en Linux. / Windows, macOS y Linux.

操作系统 —— Linux 原生。/ Windows、macOS 与 Linux。

Consumo de Recursos — Muy bajo. Corre directo sobre el sistema operativo / Medio-Alto. Requiere una máquina virtual ligera.

资源占用 —— 极低,直接跑在操作系统上。/ 中到高,需要一台轻量虚拟机。

Kubernetes integrado — No (requiere instalarlo aparte). / Sí, se activa con un solo clic.

内置 Kubernetes —— 否(需另行安装)。/ 是,一键启用。

Docker Compose — Se instala como un plugin separado. / Viene preinstalado y listo para usar.

Docker Compose —— 作为独立插件安装。/ 预装即用。

Licencia y Costo — 100% Gratis y de código abierto (Apache 2.0). / Gratis para uso personal y pequeñas empresas. De pago para grandes empresas.

许可与费用 —— 100% 免费且开源(Apache 2.0)。/ 个人与小企业免费,大企业付费。

七行里最该背的是资源占用与操作系统两行:Engine 直接跑在 Linux 内核上(开销极低),Desktop 为了在 Windows/macOS 上跑 Linux 容器,必须塞一台轻量 VM。考试问「为什么 Mac 上容器启动比 Linux 慢/占内存」,答案就在这一行。
原文左上残留孤立数字 14(模板编号未删);表格多处行尾带多余空格。照抄不改。
许可这条最容易踩:Engine 是 Apache 2.0,随便用;Desktop 对「大企业」收费(通常指 250 人以上或年营收 1000 万美元以上)。所以生产服务器一律只装 Engine——这也是本课程虚拟机里只装 Engine 的原因。
p.86

Instalación de Docker Engine · Engine 安装步骤(仅作参考,别执行)

▸ 原页截图 p.86(页脚印 94) 原讲义第 86 页

Instalación de docker engine (solo como referencia, no hacerlo!)

Docker Engine 安装(仅作参考,不要执行!)。

(!!OJO: no ejecutar esto!!! En la máquina virtual, ya hay una instalación del Docker Engine. Solo es como referencia.

(注意:不要执行这些命令!!!虚拟机里已经装好 Docker Engine,这里只是参考。)

Docker Engine no necesita una máquina virtual y tiene una licencia más flexible.

Docker Engine 不需要虚拟机,且许可更宽松。

Limpiar contenido previo:

清理旧内容:

(Descarga de clave de seguridad y almacenamiento en fichero):

(下载安全密钥并写入文件):

Agrega el repositorio oficial a las fuentes del gestor de paquetes:

把官方仓库加入包管理器的源列表:

Instalación de docker engine:

安装 Docker Engine:

Verificación:

验证:

(Opcional) Ejecutar Docker sin sudo:

(可选)免 sudo 运行 Docker:

出处 p.86(讲义截图转录;PDF 因排版把长 URL 与命令折行,这里按逻辑复原为一行的形式)
# 1) 清理可能冲突的旧包
sudo apt update ; sudo apt remove docker.io docker-doc docker-compose podman-docker containerd runc

# 2) 安装前置依赖
sudo apt install apt-transport-https ca-certificates curl software-properties-common

# 3) 下载 GPG 密钥
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 4) 添加官方软件源
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 5) 安装 Engine 全家桶
sudo apt update ; sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# 6) 验证
sudo systemctl status docker ; sudo docker run hello-world

# 7) 可选:免 sudo(把当前用户加入 docker 组)
sudo groupadd docker
sudo usermod -aG docker $USER
七步按「清旧 → 装依赖 → 加密钥 → 加源 → 装包 → 验证 → 免 sudo」记。考点:docker-ce 是引擎本体,docker-ce-cli 是客户端,containerd.io 是底层运行时;docker-buildx-plugin 提供多架构构建,docker-compose-plugin 才是新版 Compose(docker compose 而非 docker-compose)。
原文三处排版事故:① 第 5 步末尾 docker-compose-plugin$ docker images –q 两条命令被粘在一行,且 $ 是提示符不是命令;② –q 用的是 en dash(–)而不是两个半角连字符(--q),照打会报错;③ 最后一行 sudo groupadd docker sudo usermod -aG docker $USER 两条命令之间没有分隔符,原 PDF 是分行显示的。全部照抄不改。
加入 docker 组 = 拿到 root:第 7 步让你以后不用敲 sudo,但本质是把 /var/run/docker.sock 的写权限给了你——能操作 socket 就能挂载宿主根目录进容器,等于 root。生产环境更推荐 rootless 模式或 sudo 白名单。
p.87

Instalación de Docker Desktop · Desktop 安装(本课不用)

▸ 原页截图 p.87(页脚印 95) 原讲义第 87 页

Instalación de docker desktop (solo como referencia, no hacerlo en la máquina virtual)

Docker Desktop 安装(仅作参考,不要在虚拟机里执行)。

Docker desktop es una plataforma útil para el desarrollo de contenedores.

Docker Desktop 是一个便于容器开发的平台。

NO vamos a usarla en la máquina virtual porque usaremos docker engine directamente sobre la máquina virtual

我们不会在虚拟机里用它,因为我们要直接在虚拟机上使用 Docker Engine。

Podéis instalarlo en vuestras máquinas por comodidad para algunos iniciales:

你们可以在自己机器上安装,方便做一些入门操作:

https://docs.docker.com/get-started/get-docker/

https://docs.docker.com/get-started/get-docker/

这页的考点是「课程环境选择」:虚拟机里用 Engine(轻、无 GUI、贴近生产),自己的电脑上想图省事可以装 Desktop。若考试让你描述实验环境,一句话:Ubuntu 虚拟机 + Docker Engine + 通过 socket 用 CLI 操作。
原文 para algunos iniciales 搭配生硬(西语一般说 para las primeras pruebas 或 para empezar);项目符号前两条用 •、第三条却是行首 • 紧贴文字,排版不齐。照抄不改。
别在虚拟机里装 Desktop:Desktop 自己要再套一层 VM,而你已经在 VM 里了——套娃之后资源翻倍、网络更绕。虚拟机里只装 Engine,用 docker 命令操作即可。

十三、镜像查询与本地管理

p.88–p.95
p.88

Consulta de Imágenes con Docker · 用命令查询本地镜像

▸ 原页截图 p.88(页脚印 96) 原讲义第 88 页

Consulta de Imágenes con Docker

用 Docker 查询镜像。

Consulta de las imágenes disponibles

查询可用镜像。

!!OJO , no usar commandos para purgar la cache de imágenes, pueden afectar al curso!!

注意:不要用命令清空镜像缓存,可能影响课程环境!!

(la primera vez, vacio, si no se hubiera hecho nada antes): $ docker images

(第一次执行、此前没做过任何操作时,输出为空):$ docker images

(sin truncar): $ docker images –no-trunc

(不截断 digest):$ docker images –no-trunc

(solamente comienzo del digest): $ docker images –q

(只显示 digest 开头 / 仅镜像 ID):$ docker images –q

(solamente imagenes de un repositorio en concreto): $ docker images <repository>

(只看某个仓库的镜像):$ docker images <repository>

Consulta de etiquetas con skopeo: $ skopeo list-tags docker://docker.io/library/hello-world

用 skopeo 查询标签:$ skopeo list-tags docker://docker.io/library/hello-world

出处 p.88(讲义截图转录)
docker images                 # 列出本地镜像
docker images --no-trunc      # 显示完整 IMAGE ID / digest
docker images -q              # 只输出镜像 ID
docker images <repository>    # 只列某仓库的镜像
skopeo list-tags docker://docker.io/library/hello-world
四条 docker images 的变体要能对上号:裸命令看全表;--no-trunc 看完整 ID;-q 只出 ID(写脚本时常用,如 docker rmi $(docker images -q));带仓库名只筛该仓库。考试常考「-q 输出的是什么」——是 IMAGE ID,不是 digest 全文。
原文把双连字符写成了 en dash:docker images –no-trunc、docker images –q 里的 – 是排版符号,真实命令必须用两个半角连字符 --no-trunc / -q。另有两处拼写:commandos 应为 comandos,vacio 应为 vacío。照抄不改。
为什么老师反复警告别清缓存:课程 VM 里预置的镜像层是共享的,docker system prune -a 一敲,全班后续实验都得重新拉几个 G。这也顺带说明:镜像缓存是「省时间」的核心资产,不是垃圾。
p.89

Consulta de imágenes con Docker Desktop · 用桌面版查镜像

▸ 原页截图 p.89(页脚印 97) 原讲义第 89 页

Consulta de imágenes con docker desktop

用 Docker Desktop 查询镜像。

La pestaña Images muestra las imágenes locales

「Images」标签页显示本地镜像。

“Search” en la barra superior busca también externamente

顶部的「Search」还会到外部(Docker Hub)搜索。

Buscad por ejemplo hello-world o alpine

比如搜一下 hello-world 或 alpine。

Desktop 的搜索框是「本地 + 远程二合一」:左边栏 Images 只列本地已有的,顶部 Search 会顺带查 Docker Hub。考试若问「Desktop 与 CLI 查镜像的区别」,答:CLI 的 docker images 只查本地,查远程要用 docker search 或 skopeo。
原文第二条的引号用了弯引号 “Search”,与全文其他直引号不统一;两处 docker desktop 均小写。照抄不改。
界面即文档:Desktop 左侧那排 Containers / Images / Volumes / Kubernetes / Builds,正好就是本课程后面要讲的五类对象——它其实就是把 CLI 的 docker ps / images / volume ls / kubectl / build 做成了按钮。
p.90

Consulta de imágenes con Docker Desktop · 界面截图:搜索 alpine

▸ 原页截图 p.90(页脚印 98) 原讲义第 90 页

Consulta de imágenes con docker desktop

用 Docker Desktop 查询镜像(本页为纯界面截图)。

界面区域(原文)中文说明
docker desktop PERSONAL左上角品牌与授权类型(个人版)。
Search: alpine Ctrl K顶部搜索框,已输入 alpine;Ctrl+K 唤起。
Containers / Images / Volumes / Kubernetes / Builds / Models / MCP Toolkit BETA / Docker Hub / Docker Scout / Extensions左侧导航栏的十个入口。
Images (100) Containers (0) Volumes (0) Extensions (0) Docs (4)搜索结果分类页签及命中数量。
Hub images (100) Hub private repos (0) Local images (0)二级筛选:远程公开 / 远程私有 / 本地。
alpine — Tag: latest → Pull / Run官方 alpine 镜像,可选标签,右侧「拉取」「运行」按钮。
latest 3.24.2 3.24 3.23.6 3.23Tag 下拉列表中的具体版本。
alpine/git 500M+ ★252 / alpine/socat 50M+ ★120 / alpine/curl 100M+ ★14其余搜索结果:下载量与星标数。
这张图其实是「镜像引用的活教材」:界面上的 alpine 就是 repository,Tag 下拉里的 3.24 就是 tag,合起来才是完整引用 docker.io/library/alpine:3.24。考试让你「说明如何选择一个具体版本」,照着这个下拉答即可。
原文页面上 Search: alpine 的冒号与输入内容同排显示,属于截图 UI 文案,不是讲义正文;标签列表在截图里处于展开状态,实际默认只显示 latest。
别被「100 个结果」骗了:搜 alpine 出来的 alpine/git、alpine/socat、alpine/curl 都是社区镜像(namespace 不是 library),只有蓝色鲸鱼标识的 alpine 才是 Docker 官方维护。选镜像先看 namespace,再看星标和下载量。
版本号怎么读:3.24.2 = 主.次.修订;3.24 = 跟着次版本走(自动收修订补丁);latest = 浮动最新。生产锁到 3.24.2 或 digest,开发图省事可用 3.24。
p.91

Consulta de imágenes con Docker Desktop · 界面截图:本地镜像列表

▸ 原页截图 p.91(页脚印 99) 原讲义第 91 页

Consulta de imágenes con docker desktop

用 Docker Desktop 查询镜像(本页为纯界面截图)。

界面元素(原文)中文说明
Images Local My HubImages 页签下的两个来源:本地 / 我的 Hub 仓库。
4.31 GB / 7.68 GB in use 13 images磁盘占用(已用 / 上限)与镜像总数。
Last refresh: 30 minutes ago上次刷新时间(30 分钟前)。
Name Tag Image ID Created Size Actions列表六列:名称、标签、镜像 ID、创建时间、大小、操作。
hello-world latest f7931603f70e 1 year ago 20.34 KB第一行:latest 标签,约 20 KB。
hello-world linux 5e22040d441e 7 months ago 20.39 KB第二行:linux 标签,另一套 ID 与大小。
这张截图正好演示 p.80 的「一个仓库多个 tag」:hello-world 仓库下挂着 latest 与 linux 两个 tag,各有独立 IMAGE ID。考试问「同一镜像的不同 tag 是不是同一个镜像文件」——不是,tag 指向的 manifest 可以不同,因此 ID 与体积都可以不同。
截图里的 Image ID 是 12 位短哈希(完整 64 位需 --no-trunc);20.34 KB 这种「小得离谱」的镜像正是 hello-world 的特征——它只包含一个打印字符串的静态二进制。
Desktop 的表格 = CLI 的列:docker images 输出 REPOSITORY / TAG / IMAGE ID / CREATED / SIZE,和这张表一一对应;Desktop 只是多加了 Actions(运行、删除)两个按钮。
p.92

Inspección de imágenes via CLI · 用 inspect 查看镜像配置

▸ 原页截图 p.92(页脚印 100) 原讲义第 92 页

Inspección de imágenes via CLI

通过 CLI 检查镜像。

docker inspect permite observer el contenido de la configuración de la imagen.

docker inspect 可以查看镜像配置的内容。

Ayuda sobre inspect: $ docker inspect --help

查看 inspect 帮助:$ docker inspect --help

(chequea el contenido) :$ docker inspect hello-world:latest

(检查内容):$ docker inspect hello-world:latest

$ docker inspect hello-world:latest --format '{{index .RepoDigests 0}} '

取第一个 RepoDigest(注册表里的 digest)。

$ docker inspect hello-world:latest --format '{{json .Created}}'

以 JSON 形式输出创建时间。

$ docker inspect hello-world --format "{{.RepoTags}}"

输出该镜像的所有仓库标签。

$ docker inspect hello-world --format "{{.Architecture}}"

输出镜像架构(amd64 / arm64…)。

$ docker inspect hello-world --format "{{.Config.ExposedPorts}}"

输出配置里声明的暴露端口。

$ docker inspect hello-world --format "{{.Config.Env}}"

输出环境变量列表。

$ docker inspect hello-world --format "{{.RootFS.Layers}}"

输出根文件系统的所有层 digest。

...

……(原文以省略号表示还有更多字段)

!!OJO!!, si probais en windows: el CLI puede que espere comilas dobles ""

注意:在 Windows 上测试时,CLI 可能要求使用双引号 ""。

出处 p.92(讲义截图转录)
docker inspect hello-world:latest
docker inspect hello-world:latest --format '{{index .RepoDigests 0}}'
docker inspect hello-world:latest --format '{{json .Created}}'
docker inspect hello-world --format "{{.RepoTags}}"
docker inspect hello-world --format "{{.Architecture}}"
docker inspect hello-world --format "{{.Config.ExposedPorts}}"
docker inspect hello-world --format "{{.Config.Env}}"
docker inspect hello-world --format "{{.RootFS.Layers}}"
六个 --format 字段就是考试的「六连问」:digest(.RepoDigests)、创建时间(.Created)、标签(.RepoTags)、架构(.Architecture)、端口(.Config.ExposedPorts)、环境变量(.Config.Env)、层(.RootFS.Layers)。注意 --format 里是 Go 模板语法:字段前有 .,数组用 index 取值。
原文 observer 应为 observar;comilas 应为 comillas;) :$ 冒号与 $ 之间缺空格;'{{index .RepoDigests 0}} ' 末尾多一个空格。全部照抄不改。
单引号 vs 双引号的坑:Linux/macOS 下 '{{...}}' 单引号最稳;Windows PowerShell 不认单引号包裹的模板里有 $ 的情况,所以原文提醒用双引号。这也是为什么同一个命令在你电脑上跑不通、在老师机器上却没事。
p.93

Historia y Capas con docker CLI · 用 history 看每一层怎么来的

▸ 原页截图 p.93(页脚印 101) 原讲义第 93 页

Historia y Capas con docker CLI

用 Docker CLI 查看历史与分层。

Cada capa se corresponde con un comando docker.

每一层都对应一条 Docker 指令。

Se puede inspeccionar con el comando history:

可以用 history 命令来查看:

docker image history --help

docker image history --help

Consultar la historia de las imagenes:

查询这些镜像的历史:

hello-world, alpine, nginx, python

hello-world、alpine、nginx、python。

出处 p.93(讲义截图转录)
docker image history --help
docker image history hello-world
docker image history alpine
docker image history nginx
docker image history python
考点是「层数 ≠ 指令数」:RUN / COPY / ADD 会改动文件系统,各生成一层;ENV / CMD / LABEL / EXPOSE 只改元数据,显示为 0 B 但不单独占层。对照下一批 p.94 的 nginx 历史图,你会看到一堆 0 B 的 ENV——这就是证据。
原文 Cada capa se corresponde con un comando docker 是简化说法(严格讲只有改变文件系统的指令才产生层),docker image history --help 行尾带多余空格。照抄不改。
history 的正确用法:拿到一个来路不明的镜像,先 docker image history --no-trunc 镜像名,就能看到构建时执行过的完整命令——包括有人不小心 ENV PASSWORD=... 写进镜像的黑历史。这是镜像审计的第一招。
p.94

Historia y Capas con Docker Desktop · 界面截图:nginx 的 8 层

▸ 原页截图 p.94(页脚印 102) 原讲义第 94 页

Historia y Capas con docker Docker Desktop

用 Docker Desktop 查看历史与分层。

Seleccionando la imagen se ve la historia directamente.

选中镜像即可直接看到历史。

Layers (16)

层(共 16 层)。

#指令(截图原文,节选前 8 层)大小
0# debian sh -arch amd64 out 'trixie'67.67 MB
1LABEL maintainer=NGINX Docker Main…0 B
2ENV NGINX_VERSION=1.31.70 B
3ENV NJS_VERSION=1.0.20 B
4ENV NJS_RELEASE=1~trixie0 B
5ENV ACME_VERSION=0.4.10 B
6ENV PKG_RELEASE=1~trixie0 B
7ENV DYNPKG_RELEASE=1~trixie0 B
8RUN /bin/sh -c set -x && groupadd --sys…88.83 MB
这张图是「0 B 元数据层」的铁证:第 1–7 层全是 LABEL / ENV,大小都是 0 B,但它们仍然占「history 条目」。考试若给一张 history 截图问「有几层真正占空间」,数非 0 B 的行即可(这里是第 0 层 67.67 MB + 第 8 层 88.83 MB)。
原文标题 Historia y Capas con docker Docker Desktop 出现 docker 重复;截图中的 Layers (16) 与可见行数(只显示前 9 行)不一致,是因为列表可滚动。照抄不改。
为什么基础层是 67 MB:第 0 层是 Debian trixie 根文件系统——这是「地基」。你在它上面 RUN apt install nginx(第 8 层)才长出 88 MB。所以优化镜像的第一刀永远是「换更小的地基」(如 alpine / slim / distroless)。
p.95

Descarga (pull) de imagen via CLI · 拉取镜像并观察体积

▸ 原页截图 p.95(页脚印 103) 原讲义第 95 页

Descarga (pull) de imagen via CLI

通过 CLI 拉取镜像。

Comprobad la descarga de imagenes: descargad una imagen y mirad qué ocupa.

验证镜像下载:拉一个镜像,看看它占多少空间。

(la primera vez, vacio)

(第一次执行时为空。)

$ docker pull ubuntu:22.04

$ docker pull ubuntu:22.04

22.04: Pulling from library/ubuntu / a1b2c3d4e5f6: Pull complete

22.04: Pulling from library/ubuntu / a1b2c3d4e5f6: Pull complete

$ docker pull hello-world:latest

$ docker pull hello-world:latest

$ docker pull hello-world:linux

$ docker pull hello-world:linux

$ docker pull hello-world@sha256:<digest obtenido en slide anterior>

按 digest 拉取:$ docker pull hello-world@sha256:<上一页得到的 digest>

Fijaos en el tamaño: 78 MB para un Ubuntu completo. Una VM con Ubuntu ocuparía varios GB. La siguiente slide explica por qué.

注意体积:一个完整的 Ubuntu 只有 78 MB,而 Ubuntu 虚拟机要占好几个 GB。下一页解释原因。

出处 p.95(讲义截图转录)
docker images                       # 第一次:空
docker pull ubuntu:22.04
# 22.04: Pulling from library/ubuntu
# a1b2c3d4e5f6: Pull complete
docker images
# REPOSITORY   TAG     IMAGE ID       SIZE
# ubuntu       22.04   a1b2c3d4e5f6   77.8MB

docker pull hello-world:latest
docker pull hello-world:linux
docker pull hello-world@sha256:<digest>
三种拉取方式正好演示 p.80 的引用语法::latest(默认 tag)、:linux(指定 tag)、@sha256:…(按 digest 锁定)。考试最爱问「哪种方式能保证每次拿到一模一样的内容」——只有 digest。
原文 vacio 应为 vacío;输出里的 a1b2c3d4e5f6 是示意用的假哈希(真实层 ID 是随机 sha256 前缀),77.8MB 也与当前 ubuntu:22.04 实际体积有出入。照抄不改。
78 MB 的 Ubuntu 是「压缩后」的体积:docker images 显示的是解压后的磁盘占用;传输时是压缩层,通常更小。这就是为什么下载进度条上的数字和最终 SIZE 对不上——别慌,不是下错了。

十四、镜像分层:只读模板与写时复制

p.96–p.97
p.96

Imágenes: qué son y por qué van en capas · 镜像是什么、为什么分层

▸ 原页截图 p.96(页脚印 104) 原讲义第 96 页

Imágenes: qué son y por qué van en capas

镜像:是什么,以及为什么分层。

La diferencia con un contenedor

与容器的区别。

Una imagen es una plantilla de solo lectura, formada por capas apiladas.

镜像是只读模板,由层层叠加的层构成。

Cada capa registra los cambios respecto a la anterior (de cada commando que cambia el Sistema de ficheros).

每一层记录相对上一层的改动(来自每条会修改文件系统的指令)。

E incluye metadatos para que un entorno de ejecución de contenedores pueda lanzar procesos.

并且包含元数据,好让容器运行时能够启动进程。

Un contenedor es una instancia en ejecución de una imagen, con una capa adicional de escritura encima.

容器则是镜像的运行实例,在镜像之上多了一个可写层。

Capa de escritura — la añade el CONTENEDOR

写入层 —— 由容器添加。

CMD ["python", "app.py"]

默认启动命令。

COPY app.py /app/

把应用代码复制进镜像。

RUN pip install -r requirements.txt

安装 Python 依赖。

FROM python:3.12-slim (imagen base)

基础镜像 python:3.12-slim。

Consecuencia práctica número 1: diez contenedores de la misma imagen comparten TODAS las capas de solo lectura.

实用结论一:同一镜像的十个容器共享全部只读层。

Solo su capa de escritura es propia. De ahí la densidad.

只有各自的写入层是私有的。密度优势就来自这里。

出处 p.96(讲义示意图转录,自下而上)
┌──────────────────────────────────────────────┐
│ Capa de escritura — la añade el CONTENEDOR   │  ← 可写、每容器独有
└──────────────────────────────────────────────┘
     CMD ["python", "app.py"]        # 元数据(0 B)
     COPY app.py /app/               # 应用代码层
     RUN pip install -r requirements.txt  # 依赖层
     FROM python:3.12-slim           # 基础镜像层(最大)
这句话要能背下来:镜像 = 只读模板 + 层叠 + 元数据;容器 = 镜像 + 一个可写层 + 运行中的进程。考试爱考「十个容器占多少磁盘」——只读层共享,只多出十份写入层,所以远小于「十倍镜像大小」。
原文 commando 应为 comando;E incluye 句首应为小写 e incluye(西语连词 e 不大写);Sistema de ficheros 首字母大写不规范;页面左下还有一个孤立的 :。照抄不改。
「密度」到底指什么:同样一台 8 GB 内存的机器,跑 VM 可能只能起 8 台(每台 1 GB 打底);跑容器能起上百个,因为内核、基础层全都共享。这就是云厂商按容器计费还能赚钱的底层逻辑。
p.97

Dos consecuencias de las capas · 分层带来的两个后果

▸ 原页截图 p.97(页脚印 105) 原讲义第 97 页

Dos consecuencias de las capas

分层带来的两个后果。

Una buena y una peligrosa

一个好消息,一个危险信号。

La buena: caché de construcción

好消息:构建缓存。

Si una capa no cambia, Docker la reutiliza y no la reconstruye.

如果某层没变,Docker 就直接复用它,不会重建。

Por eso conviene poner primero lo que cambia poco (instalar dependencias) y al final lo que cambia siempre (copiar el código).

所以要把「很少变的东西」放前面(安装依赖),把「每次都变的东西」放最后(拷贝代码)。

La peligrosa: nada se borra

危险的一面:什么都不会真正被删掉。

Las capas son acumulativas.

层是累积叠加的。

Si copiáis un fichero con una contraseña en una capa y lo borráis en la siguiente, el borrado es solo una marca: el fichero SIGUE en la imagen y es recuperable.

如果你在某一层里拷进一个含密码的文件、又在下一层把它删掉,那次删除只是一个标记:文件仍然留在镜像里,可以被恢复出来。

Regla que hay que aprender hoy: los secretos NUNCA van dentro de una imagen. Ni en un RUN, ni en un COPY, ni "borrados después".

今天必须记住的规则:机密永远不要放进镜像。既不要写在 RUN 里,也不要写在 COPY 里,更不要指望「事后删掉」。

Se pasan en tiempo de ejecución, con variables de entorno o con objetos Secret.

机密要在运行时传入:用环境变量,或用 Secret 对象。

Volveremos a ello en la Sesión 17, escaneando imágenes en busca de credenciales.

第 17 讲还会回到这个话题:扫描镜像里有没有凭据。

Consecuencia de la caché: ordenar mal un Dockerfile puede convertir una reconstrucción de 5 segundos en una de varios minutos.

缓存的连带后果:Dockerfile 指令顺序排错,就能把 5 秒的重构变成好几分钟。

两个后果是一体两面,答题要成对写:缓存(层内容不变 → 命中 → 秒级重建)与 不可删(层只增不减 → 删文件只是 whiteout 标记 → 机密可被挖出)。考试常问「为什么 Dockerfile 里 COPY . . 放最后」「为什么不能把密钥写进镜像」——标准答案都在这页。
原文 copiáis / borráis 是西班牙本土的 vosotros 变位(拉美用 copian / borran);SIGUE 全大写是排版强调,不是缩写;页脚印 105 而物理页序为 97,本讲义一律按物理页序编号。照抄不改。
「删除只是贴了张便签」:OverlayFS 删文件不是擦除,而是在上层放一个 whiteout 标记,下层原件一动不动。所以镜像体积不会因为 RUN rm 变小——想变小只能在同一条 RUN 里下载完就用完即删。

十五、Dockerfile:九条指令与构建缓存

p.98–p.101
p.98

Tarea — ver las capas de una imagen · 任务:看清一个镜像的层

▸ 原页截图 p.98(页脚印 106) 原讲义第 98 页

Tarea — ver las capas de una imagen

任务:查看一个镜像的层。

La historia de una imagen muestra qué instrucción creó cada capa y cuánto ocupa. Es la forma de ver dónde se va el tamaño.

镜像的「历史」会告诉你每一层是哪条指令造出来的、占多大。想知道体积都花在哪儿,就看它。

IMAGECREATEDCREATED BYSIZE
a1b2c3d42 weeks ago/bin/sh -c #(nop) CMD ["/bin/b0B
<missing>2 weeks ago/bin/sh -c #(nop) ADD file:...77.8MB
出处 p.98(讲义截图转录)
$ docker history ubuntu:22.04

$ docker image inspect ubuntu:22.04 --format '{{len .RootFS.Layers}}'

# Comparad el tamano de tres imagenes del mismo servicio
$ docker pull nginx:latest && docker pull nginx:alpine
$ docker images | grep nginx

Anotad la diferencia de tamaño: entre nginx:latest y nginx:alpine. En la Sesión 17 veréis que también se traduce en menos vulnerabilidades.

把两者的体积差记下来:nginx:latest 与 nginx:alpine。第 17 讲你会看到,这还直接换算成「更少的漏洞」。

docker history 回答「哪条指令造的、多大」;--format '{{len .RootFS.Layers}}' 一行直接吐出层数。考试爱考 0 B 的层:CMD、ENV、LABEL、EXPOSE 只写元数据,不占空间。<missing> 不是错误,表示该层来自别的镜像、本地没有独立 ID。
原文 tamano 应为 tamaño、imagenes 应为 imágenes(漏 ñ 与重音);0B 与 77.8MB 单位写法不统一;a1b2c3d4 是示意假哈希;ADD file:... 被截断。照抄不改。
看到 <missing> 别慌:它只说明这层的 ID 在本地被「折叠」了(通常来自基础镜像的导入层)。层本身在,文件也在,只是没有一个可单独 docker tag 的名字。
p.99

El Dockerfile: la receta de una imagen · Dockerfile:镜像的配方

▸ 原页截图 p.99(页脚印 107) 原讲义第 99 页

El Dockerfile: la receta de una imagen

Dockerfile:一个镜像的配方。

Las instrucciones que hay que conocer

必须认识的指令。

InstrucciónQué hace
FROM imagenImagen base. Obligatoria y siempre la primera instrucción.
WORKDIR /rutaCambia el directorio de trabajo para las instrucciones siguientes.
COPY origen destinoCopia ficheros del contexto de construcción a la imagen. Crea capa.
RUN comandoEjecuta un comando durante la CONSTRUCCIÓN. Crea capa.
ENV CLAVE=valorDefine una variable de entorno para la ejecución.
EXPOSE puertoDocumenta en qué puerto escucha. NO abre nada (ver aviso).
USER usuarioCambia el usuario con el que se ejecuta. Por defecto es root.
CMD ["prog","arg"]Comando por defecto al ARRANCAR el contenedor. No crea capa.

RUN frente a CMD: RUN se ejecuta una vez, al construir, y su resultado queda dentro de la imagen. CMD no se ejecuta al construir: es lo que se lanzará cada vez que arranque un contenedor de esa imagen.

RUN 对 CMD:RUN 只执行一次,在构建时,结果固化进镜像;CMD 在构建时根本不执行,它是每次启动容器时才跑的那条命令。

四条会建层的:FROM(基础层)、RUN、COPY、ADD;其余(WORKDIR / ENV / EXPOSE / USER / CMD / ENTRYPOINT / LABEL)都只写元数据,docker history 里显示 0 B。这张表几乎就是考试原题,能默写就稳了。
原文 EXPOSE puerto 那格说「NO abre nada」是对的:它只在镜像元数据里写个 ExposedPorts,真正对外开放端口必须靠 docker run -p 宿主:容器(本讲义 p.58 已对照过)。另外「FROM 永远是第一条」严格讲有例外:ARG 可以写在 FROM 之前。照抄不改。
一句话记牢:RUN = 烤箱里的那一步(烤完就定型);CMD = 端上桌时浇的那勺酱(每次上桌才浇)。所以改 CMD 不重建任何层,改 RUN 会把它之后的层全废掉。
p.100

Tarea — construir vuestra primera imagen · 任务:构建你的第一个镜像

▸ 原页截图 p.100(页脚印 108) 原讲义第 100 页

Tarea — construir vuestra primera imagen

任务:构建你们的第一个镜像。

1

(左上角孤立的步骤序号「1」)

Escribid el Dockerfile, compilad y ejecutad. Después mirad las capas que ha generado cada línea.

写出 Dockerfile,构建并运行;然后看看每一行各自生成了哪些层。

出处 p.100(讲义截图转录)
# Dockerfile
FROM ubuntu:22.04
WORKDIR /app
RUN apt-get update && apt-get install -y --no-install-recommends curl \
    && rm -rf /var/lib/apt/lists/*
COPY saludo.sh /app/saludo.sh
ENV NOMBRE=Telematica
USER 1000:1000
CMD ["bash", "/app/saludo.sh"]

$ printf '#!/bin/bash\necho "Hola, $NOMBRE, desde $(hostname)"\n' > saludo.sh
$ docker build -t mi-imagen:v1 .
$ docker run --rm mi-imagen:v1
$ docker history mi-imagen:v1

Contad las capas: una por FROM, RUN y COPY. ENV, USER y CMD son metadatos: no crean capa. Comprobadlo.

数一数层:FROM、RUN、COPY 各一层;ENV、USER、CMD 是元数据,不建层。自己去验证一下。

三个高频扣分点全在这页:① docker build 最后那个 . 是构建上下文,不是「当前目录」这么简单——上下文里多余的文件会拖慢构建;② RUN apt-get update && install && rm -rf /var/lib/apt/lists/* 必须写在同一条 RUN 里,分开写就白删了;③ CMD ["bash","/app/saludo.sh"] 是 exec 形式,进程才是 PID 1,信号能收到。
左上角孤立的 1 是模板残留的步骤编号,原文并无配套的 2、3;USER 1000:1000 用的是数字 UID/GID,镜像里并不存在这个用户,whoami 会报错但并不妨碍运行(这也是「非 root 运行」最省事的写法)。照抄不改。
为什么 printf 用单引号:单引号保证 $NOMBRE 和 $(hostname) 原样写进脚本文件,等到容器运行时才展开。要是用双引号,就会在你自己的虚拟机上被提前求值——这是个经典坑。
p.101

Tarea — ver la caché de construcción funcionando · 任务:让构建缓存跑起来

▸ 原页截图 p.101(页脚印 109) 原讲义第 101 页

Tarea — ver la caché de construcción funcionando

任务:亲眼看到构建缓存生效。

10 min

限时 10 分钟。

Modificad solo el script y reconstruid. Docker debe reutilizar las capas anteriores y rehacer únicamente a partir de la que cambió.

只改脚本,然后重新构建。Docker 应当复用前面的层,只从「变了的那一层」开始重做。

构建步骤(原文输出)耗时含义
=> [1/4] FROM ubuntu:22.04CACHED基础层没变,直接复用
=> [2/4] WORKDIR /appCACHED元数据指令,命中缓存
=> [3/4] RUN apt-get update && apt-get install ...CACHED依赖层没变,省下最贵的一步
=> [4/4] COPY saludo.sh /app/saludo.sh0.1s只有这层真的重建
出处 p.101(讲义截图转录)
$ echo 'echo "linea nueva"' >> saludo.sh
$ docker build -t mi-imagen:v2 .

# Ahora probad al reves: cambiad la linea RUN y reconstruid.
# Todas las capas POSTERIORES se invalidan tambien.

La regla de oro del Dockerfile: lo que cambia poco, arriba. Lo que cambia en cada commit (vuestro código), abajo del todo.

Dockerfile 的黄金法则:变得少的放上面,每次提交都变的(你的代码)放最下面。

缓存是逐层向下失效的:命中就继续往下比,一旦某层变了,它下面所有层全部作废。所以考题里「把 COPY . . 放在 RUN npm install 前面会怎样」——答案:改一行代码就重装全部依赖。
原文 al reves 应为 al revés、tambien 应为 también(漏重音);POSTERIORES 全大写是排版强调。另外输出写作 [1/4]…[4/4],但 p.100 的 Dockerfile 有 7 条指令——这里只统计了会建层的步骤(FROM/WORKDIR/RUN/COPY),是简化说法。照抄不改。
口诀「稳在上、漂在下」:系统包 → 语言依赖 → 你的代码 → 启动命令。四层从稳到漂,缓存命中率最高。改启动命令永远不重建,改系统包永远全重建。

十六、再谈隔离:namespace 与 cgroup 实操

p.102–p.106
p.102

Primera pieza del aislamiento: namespaces · 隔离的第一块拼图:命名空间

▸ 原页截图 p.102(页脚印 110) 原讲义第 102 页

Primera pieza del aislamiento: namespaces

隔离的第一块拼图:命名空间。

Qué VE un proceso

一个进程「看得见什么」。

Un namespace es una funcionalidad del kernel de Linux que le da a un grupo de procesos una vista propia de un recurso del sistema. Existen varios tipos, y son independientes entre sí: un proceso puede tener su propia vista de la red pero compartir la de los ficheros.

命名空间是 Linux 内核的一项功能:它给一组进程一份属于自己的系统资源视图。类型有好几种,彼此独立——一个进程可以拥有自己的网络视图,却与他人共享文件系统视图。

NamespaceQué aísla
pidLos identificadores de proceso. Dentro, vuestro proceso puede ser el PID 1.
netInterfaces de red, tabla de rutas y reglas de firewall. Protagonista de la Sesión 2.
mntLos sistemas de ficheros montados. Aquí es donde entra la imagen.
utsEl nombre de host.
ipcComunicación entre procesos: memoria compartida, colas de mensajes.
userLa correspondencia de usuarios: ser root dentro sin serlo fuera.

La palabra clave es "vista": el proceso no está en otra máquina: está en la misma, pero solo se le enseña una parte.

关键词是「视图」:进程没有跑到另一台机器上——它就在同一台,只是你只给它看了其中一部分。

六个必背:pid / net / mnt / uts / ipc / user。考试最爱问「哪个 namespace 决定容器里的进程是不是 PID 1」→ pid;「哪个让容器看到自己的网卡和路由」→ net;「哪个让容器内的 root 不是宿主机的 root」→ user。第 2 讲整讲都在扩 net。
原文 "vista" 用的是英文直引号,西语排版应为 «vista» 或 “vista”;ficheros 是西班牙用法(拉美多说 archivos);Protagonista de la Sesión 2 句首缺冠词,属口语化省略。照抄不改。
「六个窗口」记忆法:进程号(pid)、网线(net)、盘(mnt)、门牌(uts)、传纸条(ipc)、身份(user)。六个窗口各自拉窗帘,互不影响——这就是为什么可以只隔离网络而共享磁盘。
p.103

Tarea — ver el namespace pid en acción · 任务:亲眼看 pid 命名空间

▸ 原页截图 p.103(页脚印 112) 原讲义第 103 页

Tarea — ver el namespace pid en acción

任务:让 pid 命名空间现场表演。

10 min

限时 10 分钟。

Arrancad un contenedor y comparad qué PID tiene el mismo proceso visto desde dentro y visto desde la VM.

起一个容器,对比「同一个进程」在容器内部看到的 PID 和在虚拟机里看到的 PID。

出处 p.103(讲义截图转录)
$ docker run -d --name c1 ubuntu:22.04 sleep 600

# Visto DESDE DENTRO del contenedor
$ docker exec c1 ps aux
USER   PID  COMMAND
root     1  sleep 600        <-- es el PID 1

# El MISMO proceso, visto desde la VM
$ ps -ef | grep "sleep 600" | grep -v grep
root  48213  ...  sleep 600   <-- aqui es el 48213

Un solo proceso, dos identidades: no hay dos procesos: hay uno, con dos numeraciones distintas según desde dónde se mire. Eso es el namespace pid.

一个进程,两个身份:根本不是两个进程,只有一个,只是从哪儿看就有两套编号。这就是 pid 命名空间。

Consultad el cgroup al que pertenece el proceso sleep.

再查一下这个 sleep 进程属于哪个 cgroup。

「容器里的 1 号进程」就这么来的:pid 命名空间给了容器一张全新的进程编号表,第一个进程自然是 1。这也解释了为什么容器里的 PID 1 要负责回收僵尸进程——它不像宿主机的 init 那样自带这个能力(docker run --init 就是补这个的)。
原文 PID 1 那句的箭头写法 <-- 是代码注释风格,不是 HTML;48213 只是示例数字,你机器上一定不同;页脚印 112(物理页序 103),中间缺印 111,说明导出时删过幻灯片。照抄不改。
「同一只猫,两个门牌号」:猫还是那只猫,从院子里看它叫「48213 号」,从屋里看它叫「1 号」。ps 只是个查号台,它报的号取决于你站在哪个命名空间里。
p.104

Tarea — ver los namespaces directamente en el kernel · 任务:直接在内核里看命名空间

▸ 原页截图 p.104(页脚印 114) 原讲义第 104 页

Tarea — ver los namespaces directamente en el kernel

任务:绕过 Docker,直接去内核里看命名空间。

Los namespaces no son un invento de Docker: son objetos del kernel, y se pueden listar. Comprobad que el contenedor tiene identificadores distintos a los de la VM.

命名空间不是 Docker 发明的:它们是内核对象,可以列出来。去验证容器拿到的编号确实和虚拟机的不一样。

出处 p.104(讲义截图转录)
# Namespaces de la propia VM
$ sudo ls -l /proc/1/ns/
net -> net:[4026531840]
pid -> pid:[4026531836]

# Namespaces del proceso que corre dentro del contenedor
$ PID=$(docker inspect -f '{{.State.Pid}}' c1)
$ sudo ls -l /proc/$PID/ns/
net -> net:[4026532567]      <-- numero DISTINTO
pid -> pid:[4026532565]      <-- numero DISTINTO

$ lsns -t net -t pid | head

Sin magia: Docker no inventa aislamiento: pide al kernel namespaces nuevos y arranca el proceso dentro. Eso es todo.

没有魔法:Docker 不「发明」隔离,它只是向内核申请新的命名空间,再把进程放进去跑。就这么回事。

三个「证据链」考点:① /proc/<pid>/ns/ 下每个符号链接后面的 inode 号就是命名空间的身份证;② 号和号不同 → 隔离成立;③ lsns 能一次列出全系统的命名空间。docker inspect -f '{{.State.Pid}}' 拿到的是宿主机侧的 PID,这一步经常考。
原文页脚为 114(物理 104),缺印 113;numero 应为 número;DISTINTO 全大写是排版强调;4026531840 这类数字是内核分配的,每次开机会变。照抄不改。
看 inode 就像看「户口本编号」:同一个命名空间的进程共享同一个 inode 号,等于落在同一本户口本上。两个号一样 → 它们其实在同一间屋子里,隔离没做成——排障时这招特别灵。
p.105

Segunda pieza: cgroups · 第二块拼图:控制组

▸ 原页截图 p.105(页脚印 115) 原讲义第 105 页

Segunda pieza: cgroups

第二块拼图:cgroups(控制组)。

Cuánto puede CONSUMIR un proceso

一个进程「能吃掉多少」。

Los namespaces limitan lo que un proceso ve, pero no lo que gasta: un proceso perfectamente aislado puede consumir toda la CPU y toda la memoria de la máquina. De eso se ocupan los grupos de control (cgroups).

命名空间限制「看得见什么」,但不限制「花多少」:一个隔离得再完美的进程,照样能吃掉整台机器的 CPU 和内存。管这件事的,就是控制组。

Namespacescgroups
Qué VE un proceso.CUÁNTO consume un proceso.
pid, net, mnt, uts, ipc, user.CPU, memoria, E/S de disco, ancho de banda de red.
Si no lo ve, no puede tocarlo.Si se excede en memoria, el kernel lo termina.
出处 p.105(讲义截图转录)
docker run --memory=100m --cpus=0.5 IMAGEN

Estas dos opciones no hacen nada exótico: configuran cgroups por vosotros.

这两个选项一点也不玄乎:它们只是替你去配置 cgroups。

Volverán en la Sesión 4: los "requests" y "limits" de Kubernetes son exactamente esto, con otro nombre.

第 4 讲还会遇到它们:Kubernetes 里的 requests 和 limits 就是这玩意儿,换了个名字而已。

一句话对照必背:namespace = 看得见什么(visibility);cgroup = 用得了多少(accounting + enforcement)。考题常给一个场景问「该用哪个」——「容器里看到 64 个 CPU 但宿主机只有 4 个」是 cgroup/CPU 配额问题,「容器里 ps 只看到自己」是 namespace 问题。
原文 E/S de disco,ancho 逗号后缺空格;"requests" / "limits" 用英文直引号,西语排版应为 «requests»;“CUÁNTO” 与 “VE” 全大写是排版强调。照抄不改。
「窗帘 vs 电表」:namespace 是窗帘——决定你能看到几间房;cgroup 是电表加空气开关——决定你能用多少电、超了直接跳闸(OOM Kill)。装了窗帘不等于省电,这正是很多人对容器的误解。
p.106

Tarea — comprobar un límite de cgroups · 任务:验证 cgroup 限额真的会动手

▸ 原页截图 p.106(页脚印 116) 原讲义第 106 页

Tarea — comprobar un límite de cgroups

任务:验证 cgroup 内存限额。

1

(左上角孤立的步骤序号「1」)

Poned un límite de memoria y forzad al contenedor a superarlo. El kernel lo terminará: veréis el estado OOMKilled.

给容器设一个内存上限,然后逼它超。内核会把它杀掉:你会看到 OOMKilled 状态。

出处 p.106(讲义截图转录)
$ docker run -d --name limitado --memory=100m --cpus=0.5 ubuntu:22.04 sleep 600
$ docker inspect limitado --format '{{.HostConfig.Memory}}'
104857600        # 100 MB en bytes
$ docker stats limitado --no-stream
CONTAINER   CPU %   MEM USAGE / LIMIT
limitado    0.00%   1.2MiB / 100MiB

# Ahora forzad el limite: reservad 200 MB con un límite de 100
$ docker run --rm --memory=100m ubuntu:22.04 \
    bash -c "tail /dev/zero"    # consume memoria sin parar
$ echo "codigo de salida: $?"   # 137 = terminado por el kernel

El 137 es la prueba: 128 + 9: el proceso recibió una señal KILL. El límite de cgroups no es una sugerencia.

137 就是证据:128 + 9,说明进程收到了 KILL 信号。cgroup 的限额不是「建议」。

数字要背:137 = 128 + 9 = SIGKILL;143 = 128 + 15 = SIGTERM;1 MiB = 1048576 字节,所以 --memory=100m 在 HostConfig.Memory 里就是 104857600。看懂退出码,你就能一秒判断「是程序自己崩了,还是被内核/编排器杀了」。
左上角又是孤立的 1,与 p.100 同款模板残留;limite 应为 límite、codigo 应为 código(注释里漏重音);tail /dev/zero 是教学用的「吃内存」小技巧,别在生产机上玩。照抄不改。
为什么是 137 而不是 1:被信号杀死时,shell 约定用 128 + 信号编号 作为退出码。9 是 KILL,于是 137。记住这个加法,kubectl describe pod 里的 Exit Code: 137 你就再也不会误判成「程序 bug」了。

十七、安全边界与参考书目

p.107–p.108
p.107

Un contenedor no es una caja fuerte · 容器不是保险箱

▸ 原页截图 p.107(页脚印 120) 原讲义第 107 页

Un contenedor no es una caja fuerte

容器不是保险箱。

Por defecto el proceso dentro de un contenedor se ejecuta como root — un root con capacidades recortadas, pero root. Y si se levantan esas restricciones, el aislamiento desaparece.

默认情况下容器里的进程以 root 运行——是个被削掉部分能力的 root,但仍然是 root。一旦把这些限制解除,隔离就没了。

出处 p.107(讲义截图转录)
# Un contenedor privilegiado ve TODOS los discos de la VM
$ docker run --rm ubuntu:22.04 ls /dev
$ docker run --rm --privileged ubuntu:22.04 ls /dev

# Y compartiendo el namespace pid, ve TODOS los procesos
$ docker run --rm ubuntu:22.04 ps aux | head
$ docker run --rm --pid=host ubuntu:22.04 ps aux | head

La conclusión: "--privileged" es equivalente a dar acceso de root a la máquina anfitriona. En la Sesión 17 veréis que es uno de los hallazgos que Trivy marca como grave al analizar una configuración, y en la Sesión 18, uno de los comportamientos que Falco vigila.

结论:--privileged 等于把宿主机的 root 权限交出去。第 17 讲你会看到,Trivy 扫配置时会把它标成严重问题;第 18 讲里,Falco 专门盯着这类行为。

Buena práctica desde hoy: declarad siempre USER en vuestros Dockerfile. No cuesta nada y evita ejecutar como root.

从今天起的好习惯:Dockerfile 里永远写一行 USER。不花任何成本,却能避免以 root 运行。

三个高危开关务必认清:--privileged(几乎等于宿主机 root)、--pid=host(能看见并操作宿主机全部进程)、-v /:/host(把宿主机根目录挂进去)。考试问「哪个参数最危险」——默认答案就是 --privileged。
原文 "--privileged" 用了英文直引号;「un root con capacidades recortadas, pero root」是同词反复的口语强调,不是笔误;页脚印 120(物理 107),中间缺印 117–119。照抄不改。
「root 是房卡,不是房本」:容器里的 root 通常只有一部分 capabilities(类似只给你开几扇门的房卡);--privileged 等于把整栋楼的总卡给你。默认的「房卡」还能接受,总卡就千万别乱发。
p.108

Bibliografía y recursos · 参考书目与资源

▸ 原页截图 p.108(页脚印 122) 原讲义第 108 页

Bibliografía y recursos

参考书目与资源。

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

想在本讲之外继续深入:

TipoRecurso
Doc. oficialdocs.docker.com/get-started — el tutorial oficial, con ejemplos ejecutables.
Referenciadocs.docker.com/reference/dockerfile — todas las instrucciones del Dockerfile, con su semántica exacta.
Referenciadocs.docker.com/reference/cli/docker — referencia completa de la CLI, comando por comando.
LibroDocker Deep Dive — N. Poulton (2023). Capítulos 1 a 4 cubren exactamente esta sesión.
Artículo"Namespaces in operation" — serie de M. Kerrisk en LWN.net. El detalle técnico de cada namespace.
Prácticakillercoda.com — escenarios de Docker y Linux en el navegador, para repasar sin la VM.
复习优先级按考试命中率排:Dockerfile 参考页(指令语义,考得最多)→ CLI 参考(run / build / inspect / history)→ get-started(把例子跑一遍)→ Kerrisk 的 namespace 系列(想搞懂内核细节再看)。书不必从头读,第 1–4 章正好对应本讲。
页脚印 122(物理 108),缺印 121;"Namespaces in operation" 用英文直引号;killercoda.com 是第三方练习站,界面可能改版,操作路径以站点当前版本为准。照抄不改。
无 VM 也能练:killercoda 直接在浏览器里给你一台临时 Linux,关掉即销毁。在图书馆、在别人的电脑上都能刷 docker run——练手成本为零。

十八、专有名词总表

A–Z · 全章 108 页

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

共 95 条,覆盖全 108 页的高频术语。按西语字母排序(ñ 排在 n 之后),点页码直接跳回对应页块。末列只写一句话记忆点或易错处,不重复中文列。

西语术语中文页一句话记住 / 易错点
A
ADDADD 指令p.65像 COPY 的加强版:能解 tar、能拉 URL,但构建结果不可预测,考试专考它与 COPY 的分界。
aislamiento隔离p.52容器=普通 Linux 进程+namespaces(隔离)+cgroups(限额),一句背下来。
anfitrión宿主机p.50SO anfitrión 的 kernel 由全部容器共享,这正是容器轻量的根源。
arquitectura cliente-demonio-registro客户端-守护进程-注册表三段架构p.61docker 只是客户端,干活的是 dockerd,镜像来自 registro。
B
buildx构建插件p.86docker-buildx-plugin 与 docker-ce、containerd.io 一起装。
C
caché de construcción构建缓存p.97某层不变就复用;改动上层会让它下面全部失效。
capa层p.96镜像=只读层叠加;容器=再盖一层可写层。
cgroup控制组p.8回答「能用多少」:CPU、内存、进程数。
cgroup.controllers可用控制器列表p.11只读文件,告诉你这个 cgroup 支持哪些控制器。
cgroup.freeze冻结开关p.17写 1 冻结、写 0 解冻;进程还在,只是不动。
cgroup.kill整组击杀p.18写 1 把组内所有进程一起杀掉,比逐个 kill 干净。
cgroup.procs组内进程列表p.11写 PID 进来=把进程加入该组;读它就是成员清单。
cgroup.subtree_control子树控制器开关p.12决定子 cgroup 能启用哪些控制器,例如写入 +pids。
cgroup.threads组内线程列表p.11按线程粒度管理,和 procs 的差别只在「线程 vs 进程」。
cgset / cgget设置 / 读取 cgroup 参数p.16cgset -r memory.max=2G,再用 cgget -r 读回来验证。
chroot改根目录p.41只隔离文件视角,不隔离进程与网络,所以还不是容器。
cliente DockerDocker 客户端p.61只发请求不执行,请求经 socket 交给守护进程。
CNCF云原生计算基金会p.58containerd 是 CNCF graduated 项目,Harbor 也是。
containerd容器运行时守护进程p.58向下调 runc,向上提供 CRI,是中间管理层。
contenedor容器p.50不是虚拟机:它是宿主机上一个被限制了视野和配额的普通进程。
controlador控制器p.12cpu / memory / pids / cpuset 等,各自只管一类资源。
CRI容器运行时接口p.58Kubernetes 通过 CRI 调 containerd 或 CRI-O。
CRI-O轻量 CRI 实现p.74极简 CRI 实现,底层同样用 runc。
crictlCRI 调试 CLIp.58与 nerdctl 并列,是 containerd 侧的常用工具。
cpuset.cpusCPU 亲和p.23把 cgroup 绑到指定核,例如只给 0 和 1。
D
digest摘要p.81SHA256 校验和,内容不变就永不变,生产环境用它锁版本。
Distribution分发规范p.83OCI 三规范之一,规定注册表的 /v2/ 接口。
Docker Desktop桌面版p.85Windows / macOS 上带 GUI 与虚拟机的整套环境。
Docker EngineDocker 引擎p.85Linux 上的 docker-ce + dockerd + containerd 组合。
Docker Hub官方公共注册表p.79默认 registro,library 空间放官方镜像。
docker build构建镜像p.100按 Dockerfile 逐层构建,命中缓存会显示 CACHED。
docker exec进容器执行命令p.103在已运行容器里开新进程,验证 pid namespace 就靠它。
docker history看层历史p.98一行一层,0B 的那些就是元数据指令。
docker images列本地镜像p.88-q 只看 ID,--no-trunc 不截断。
docker inspect查配置p.92--format '{{...}}' 取字段,例如 RootFS.Layers。
docker pull拉镜像p.88不写标签默认 latest;也可写 digest 精确拉取。
docker run运行容器p.62等于 pull(必要时)+create+start 的快捷方式。
docker search搜镜像p.64在 Docker Hub 上按名字搜索。
docker stats实时资源p.106看到 1.2MiB / 100MiB 就说明 memory.max 生效了。
dockerdDocker 守护进程p.61真正负责构建、运行、分发容器的那一个。
Dockerfile构建配方p.99一行一条指令,自上而下构建。
E
ENTRYPOINT入口点p.68固定入口,CMD 则充当它的默认参数。
ENV环境变量p.69构建期写入的环境变量,不产生新层。
espacio (library)命名空间 / 官方空间p.81library 是 Docker Hub 留给官方镜像的空间。
etiqueta标签p.81可以被重新指派,所以不可靠;latest 就是默认标签。
EXPOSE声明端口p.67只是文档声明,不发布端口;真正发布要靠 -p。
F
Falco运行时安全监控p.107第十八讲专讲,监控 --privileged 这类危险行为。
FROM基础镜像p.64Dockerfile 的第一条,决定整栋楼的起点。
G
gestión de registros注册表管理p.59containerd 的职责之一:镜像与注册表管理。
grupos de control控制组(复数)p.8cgroups 的西语全称写法,和 cgroup 指同一件事。
H
Harbor企业级注册表p.82CNCF graduated,比裸的 Registry v2 安全得多。
I
imagen镜像p.77只读模板,跑起来才变成容器。
Image spec镜像规范p.83manifest + configuration + layers 三件套。
K
Kata Containers安全容器p.75每个容器配独立内核,兼顾隔离强度与启动速度。
kernel compartido共享内核p.50所有容器共用宿主机内核,所以不能换成别的内核。
L
latest默认标签p.81不写标签就是它,内容随时可能被替换。
libcontainer容器库p.57runc 的前身,由 Docker 开源出来。
library官方空间p.81docker.io/library/nginx 里中间那一段。
LXCLinux 容器p.47lxc-create --name 建容器,Docker 之前的主流方案。
lsns列出命名空间p.29由 util-linux 提供,能列出系统里所有 namespace。
M
manifest清单p.83JSON 文件,列出各层 digest 与 configuration。
máquina virtual虚拟机p.49虚拟化硬件、跑完整操作系统,重但隔离强。
memory.events内存事件计数p.22看 OOM 次数,判断有没有撞上 memory.max。
memory.max内存上限p.16cgset -r memory.max=2G,超了就被内核 OOM 掉。
N
namespace命名空间p.25回答「看得见什么」:pid / net / mnt / uts / ipc / user。
namespace de red网络命名空间p.52第二单元的主角,决定容器网络隔离到什么程度。
nerdctlcontainerd 的 CLIp.58命令习惯贴近 docker,配合 containerd 使用。
nsenter进入命名空间p.43nsenter -t <pid> -m -u -i -p 逐个进入目标进程的 ns。
O
OCI开放容器倡议p.54Runtime / Image / Distribution 三条规范。
OOMKilled被 OOM 杀掉p.106内存超限后容器的终止状态,配套退出码 137。
OverlayFS叠加文件系统p.37UnionFS 在 Linux 上的实现,负责分层叠加。
P
/proc/<pid>/ns/命名空间入口目录p.104ls -l 看 inode 号,号不同=不是同一个 namespace。
pids.max进程数上限p.20写 10 就最多 10 个进程,第 11 个直接失败。
Podman无守护进程容器工具p.73rootless、不需要 dockerd,同样兼容 OCI。
--privileged特权模式p.107等于把宿主机 root 交给容器,最危险的开关。
R
registro注册表p.79存镜像的仓库,常见六个:Hub / GHCR / GitLab / ECR / ACR / GAR。
repositorio仓库p.80同一镜像不同标签的集合,是引用里的一段。
root容器内默认用户p.99不写 USER 就是 root,只是能力被裁剪过。
RUN构建时执行p.66构建时跑一次,结果写进镜像层。
runc底层运行时p.57基于 libcontainer,真正调 kernel 起进程的那一层。
runtime运行时p.56runc / containerd / CRI-O / Podman / Kata 都算这一类。
S
setns加入命名空间p.29通过符号链接把进程放进已有的 namespace。
señal信号p.106137 = 128 + 9,即进程收到 SIGKILL。
skopeo镜像搬运工具p.84inspect / copy / list-tags,不落地就能查和搬。
socket套接字p.61能读写 socket 就等价于 root,所以 docker 组是高危组。
systemd-nspawnsystemd 容器工具p.42-D 指定目录启动容器,隔离比 chroot 全得多。
T
tar归档文件p.84skopeo 可以在 tar 与 OCI 目录之间复制镜像。
Trivy漏洞扫描器p.107第十七讲专讲,会把 --privileged 标成严重问题。
U
UnionFS联合文件系统p.36把多层目录叠加成一个视图,是容器镜像的地基。
unshare新建命名空间p.29把进程挪到与父进程不同的 ns,也常用来替代 chroot。
USER运行用户p.99默认 root;最佳实践是显式声明非 root 用户。
util-linux基础工具包p.29lsns / unshare / setns / nsenter 都来自它。
V
virtualización虚拟化p.50容器不虚拟化硬件,只限制进程的视野与配额。
vista视图p.102namespace 的关键词:改变进程看到的系统视图。
W
WORKDIR工作目录p.69后续 RUN / COPY / CMD 的相对路径基准。

编号与常量速记卡

口诀:137 是 128+9,九条指令只有四条建层;三规范、五段式、六注册表、六命名空间。

编号原文关键词中文性质归类页
137128 + 9 · SIGKILL退出码=128+信号号进程终止p.106
143128 + 15 · SIGTERM被正常终止的退出码进程终止p.106
104857600100m → HostConfig.Memory100 MiB 换成的字节数单位换算p.106
0BSIZE 列元数据指令不建层,体积为零层大小p.98
77.8MBubuntu:22.04完整 Ubuntu 镜像的实测体积体积对照p.95
[1/4]–[4/4]构建步骤计数只数真正建层的步骤构建输出p.101
三Runtime / Image / DistributionOCI 三条规范标准p.54
五[registro/][espacio/]repositorio[:etiqueta][@resumen]镜像引用的五段式命名p.80
六Hub / GHCR / GitLab / ECR / ACR / GAR六个常见注册表生态p.79
九FROM … CMDDockerfile 九条指令指令p.99
四FROM / RUN / COPY / ADD只有这四条会建层指令p.99
六pid / net / mnt / uts / ipc / user本讲要记的六类 namespace隔离p.102

易混对照卡

每一对都只差一个词,考试就爱在这里挖坑。先问自己「差在哪个词上」,再往下看。

cgroups
管「能用多少」:CPU、内存、进程数。差在 量。
namespaces
管「看得见什么」:pid、net、mnt、uts、ipc、user。差在 视野。
cgroup.procs
以进程为单位加入或列出。
cgroup.threads
以线程为单位加入或列出。
cgroup.freeze
写 1 暂停,进程还在,写 0 恢复。
cgroup.kill
写 1 杀掉整组进程,不可恢复。
COPY
只复制本地文件,行为可预测、可缓存。
ADD
多出解压 tar 与下载 URL 两个动作,所以不可预测。
RUN
构建时执行一次,结果留在镜像层里。
CMD
启动时执行,只是默认命令,可被覆盖。
EXPOSE
只是声明「我监听这个端口」,不对外发布。
-p
真正发布端口,把宿主机端口映射到容器。
etiqueta
可重新指派,今天指向 A,明天可能指向 B。
digest
不可变,SHA256 锁定内容,生产环境用它。
imagen
只读模板,本体不会变。
contenedor
运行中的实例,顶上多一层可写层。
chroot
只改文件根目录,进程与网络照旧可见。
unshare
新建整套命名空间,可同时换 pid、mnt、net。
Docker Engine
Linux 上的守护进程组合:docker-ce + dockerd + containerd。
Docker Desktop
Windows / macOS 上的整套桌面环境,内含一台虚拟机。
runc
最底层:真正调 kernel 建 namespace、起进程。
containerd
管理层:管镜像、管生命周期,再调 runc。
máquina virtual
虚拟化硬件,跑完整 OS,重但隔离强。
contenedor
限制进程,共享宿主机内核,轻但隔离靠内核。