Translate another docker cheatsheets to zh-cn (#479)

* feat(docker-compose-memo): add Chinese translation and refactor locale-based memo loading

- Add docker-compose.zh.md with full Chinese translation
- Refactor docker-compose-memo.vue to dynamically load memo by current locale
- Update bash-memo.vue fallback to generic bash-memo.content.md
- Remove obsolete bash-memo.content.en.md

* feat: 添加 CSS 选择器和 Docker Swarm 的中文翻译,优化动态加载功能

* 添加 Docker 和 Dockerfile 的中文翻译,优化动态加载功能
This commit is contained in:
LuoXingchen authored and GitHub committed 2026-07-19 21:23:41 +02:00
1 parent 2abda9b71e
commit c105c1ec17
8 files changed
+1103 -8

No files matched your search

@@ -1,13 +1,36 @@
<script setup lang="ts">
import { ref, watch } from 'vue';
import { useI18n } from 'vue-i18n';
import { useThemeVars } from 'naive-ui';
import Memo from './css-selectors.md';
import type { Component } from 'vue';
const themeVars = useThemeVars();
const { locale } = useI18n();
const memoImports = import.meta.glob('./css-selectors*.md');
const memoComponent = ref<Component | null>(null);
async function loadMemo(currentLocale = locale.value) {
const memoKey = `./css-selectors.${currentLocale}.md`;
const loader = memoImports[memoKey] ?? memoImports['./css-selectors.md'];
if (!loader) {
memoComponent.value = null;
return;
}
const module = (await loader()) as { default?: Component };
memoComponent.value = module.default ?? module;
}
watch(locale, () => {
loadMemo();
}, { immediate: true });
</script>
<template>
<div>
<Memo style="overflow-x: auto;" />
<component :is="memoComponent" style="overflow-x: auto;" />
</div>
</template>
@@ -0,0 +1,63 @@
| 选择器 | 示例 | 示例说明 |
|-----------------------|-------------------------|----------------------------------------------------------------------------------------------------------|
| `.class` | `.intro` | 选择所有 class="intro" 的元素 |
| `.class1.class2` | `.name1.name2` | 选择 class 属性中同时设置了 name1 和 name2 的所有元素 |
| `.class1 .class2` | `.name1 .name2` | 选择所有 name2 元素,且这些元素是 name1 元素的后代 |
| `#id` | `#firstname` | 选择 id="firstname" 的元素 |
| `*` | `*` | 选择所有元素 |
| `element` | `p` | 选择所有 \<p\> 元素 |
| `element.class` | `p.intro` | 选择所有 class="intro" 的 \<p\> 元素 |
| `element,element` | `div, p` | 选择所有 \<div\> 元素和所有 \<p\> 元素 |
| `element element` | `div p` | 选择 \<div\> 元素内的所有 \<p\> 元素 |
| `element>element` | `div > p` | 选择父元素为 \<div\> 的所有 \<p\> 元素 |
| `element+element` | `div + p` | 选择紧接在 \<div\> 元素之后的第一个 \<p\> 元素 |
| `element1~element2` | `p ~ ul` | 选择前面有 \<p\> 元素的每个 \<ul\> 元素 |
| `[attribute]` | `[target]` | 选择所有带有 target 属性的元素 |
| `[attribute=value]` | `[target="_blank"]` | 选择所有 target="_blank" 的元素 |
| `[attribute~=value]` | `[title~="flower"]` | 选择所有 title 属性包含 "flower" 一词的元素 |
| `[attribute\|=value]` | `[lang\|="en"]` | 选择所有 lang 属性值等于 "en" 或以 "en-" 开头的元素 |
| `[attribute^=value]` | `a[href^="https"]` | 选择 href 属性值以 "https" 开头的每个 \<a\> 元素 |
| `[attribute$=value]` | `a[href$=".pdf"]` | 选择 href 属性值以 ".pdf" 结尾的每个 \<a\> 元素 |
| `[attribute*=value]` | `a[href*="w3schools"]` | 选择 href 属性值包含子串 "w3schools" 的每个 \<a\> 元素 |
| `:active` | `a:active` | 选择激活状态的链接 |
| `::after` | `p::after` | 在每个 \<p\> 元素的内容之后插入内容 |
| `::before` | `p::before` | 在每个 \<p\> 元素的内容之前插入内容 |
| `:checked` | `input:checked` | 选择每个被选中的 \<input\> 元素 |
| `:default` | `input:default` | 选择默认的 \<input\> 元素 |
| `:disabled` | `input:disabled` | 选择每个被禁用的 \<input\> 元素 |
| `:empty` | `p:empty` | 选择每个没有子元素(包括文本节点)的 \<p\> 元素 |
| `:enabled` | `input:enabled` | 选择每个可用的 \<input\> 元素 |
| `:first-child` | `p:first-child` | 选择每个作为其父元素第一个子元素的 \<p\> 元素 |
| `::first-letter` | `p::first-letter` | 选择每个 \<p\> 元素的第一个字母 |
| `::first-line` | `p::first-line` | 选择每个 \<p\> 元素的第一行 |
| `:first-of-type` | `p:first-of-type` | 选择每个作为其父元素第一个 \<p\> 元素的 \<p\> 元素 |
| `:focus` | `input:focus` | 选择获得焦点的 input 元素 |
| `:fullscreen` | `:fullscreen` | 选择处于全屏模式的元素 |
| `:has()` | `h2:has(+p)` | 选择紧跟着 p 元素的 h2 元素,并将样式应用于 h2 |
| `:hover` | `a:hover` | 选择鼠标悬停时的链接 |
| `:in-range` | `input:in-range` | 选择值在特定范围内的 input 元素 |
| `:indeterminate` | `input:indeterminate` | 选择处于不确定状态的 input 元素 |
| `:invalid` | `input:invalid` | 选择所有值无效的 input 元素 |
| `:lang()` | `p:lang(it)` | 选择每个 lang 属性等于 "it"(意大利语)的 \<p\> 元素 |
| `:last-child` | `p:last-child` | 选择每个作为其父元素最后一个子元素的 \<p\> 元素 |
| `:last-of-type` | `p:last-of-type` | 选择每个作为其父元素最后一个 \<p\> 元素的 \<p\> 元素 |
| `:link` | `a:link` | 选择所有未访问的链接 |
| `::marker` | `::marker` | 选择列表项的标记 |
| `:not()` | `:not(p)` | 选择每个不是 \<p\> 元素的元素 |
| `:nth-child()` | `p:nth-child(2)` | 选择每个作为其父元素第二个子元素的 \<p\> 元素 |
| `:nth-last-child()` | `p:nth-last-child(2)` | 选择每个作为其父元素第二个子元素的 \<p\> 元素,从最后一个子元素开始计数 |
| `:nth-last-of-type()` | `p:nth-last-of-type(2)` | 选择每个作为其父元素第二个 \<p\> 元素的 \<p\> 元素,从最后一个子元素开始计数 |
| `:nth-of-type()` | `p:nth-of-type(2)` | 选择每个作为其父元素第二个 \<p\> 元素的 \<p\> 元素 |
| `:only-of-type` | `p:only-of-type` | 选择每个作为其父元素唯一 \<p\> 元素的 \<p\> 元素 |
| `:only-child` | `p:only-child` | 选择每个作为其父元素唯一子元素的 \<p\> 元素 |
| `:optional` | `input:optional` | 选择没有 "required" 属性的 input 元素 |
| `:out-of-range` | `input:out-of-range` | 选择值超出特定范围的 input 元素 |
| `::placeholder` | `input::placeholder` | 选择指定了 "placeholder" 属性的 input 元素 |
| `:read-only` | `input:read-only` | 选择指定了 "readonly" 属性的 input 元素 |
| `:read-write` | `input:read-write` | 选择未指定 "readonly" 属性的 input 元素 |
| `:required` | `input:required` | 选择指定了 "required" 属性的 input 元素 |
| `:root` | `:root` | 选择文档的根元素 |
| `::selection` | `::selection` | 选择用户选中的元素部分 |
| `:target` | `#news:target` | 选择当前激活的 #news 元素(点击了包含该锚点名称的 URL) |
| `:valid` | `input:valid` | 选择所有值有效的 input 元素 |
| `:visited` | `a:visited` | 选择所有已访问的链接 |
+25 -2
View File
@@ -1,13 +1,36 @@
<script setup lang="ts">
import { ref, watch } from 'vue';
import { useI18n } from 'vue-i18n';
import { useThemeVars } from 'naive-ui';
import Memo from './docker.md';
import type { Component } from 'vue';
const themeVars = useThemeVars();
const { locale } = useI18n();
const memoImports = import.meta.glob('./docker*.md');
const memoComponent = ref<Component | null>(null);
async function loadMemo(currentLocale = locale.value) {
const memoKey = `./docker.${currentLocale}.md`;
const loader = memoImports[memoKey] ?? memoImports['./docker.md'];
if (!loader) {
memoComponent.value = null;
return;
}
const module = (await loader()) as { default?: Component };
memoComponent.value = module.default ?? module;
}
watch(locale, () => {
loadMemo();
}, { immediate: true });
</script>
<template>
<div>
<Memo style="overflow-x: auto;" />
<component :is="memoComponent" style="overflow-x: auto;" />
</div>
</template>
+482
View File
@@ -0,0 +1,482 @@
Docker 能够将应用程序打包并运行在一个称为容器(container)的松散隔离环境中。这种隔离性和安全性使你可以在同一台主机上同时运行多个容器。容器十分轻量,包含了运行应用所需的一切,因此你无需依赖主机上当前已安装的内容。你可以在工作时轻松地共享容器,并确保每一位共享对象都能获得以相同方式运行的相同容器。
## 安装与资源
- Docker Desktop(Mac、Linux、Windows):https://docs.docker.com/desktop
- 使用 Docker 的示例项目:https://github.com/docker/awesome-compose
- 官方文档:https://docs.docker.com
## 通用命令
启动 Docker 守护进程:
```bash
dockerd
```
获取 Docker 帮助(适用于所有子命令,例如 `docker run --help`):
```bash
docker --help
```
显示系统级信息:
```bash
docker info
```
显示 Docker 版本(客户端和服务端):
```bash
docker version
```
## 镜像
Docker 镜像是一种轻量、独立、可执行的软件包,包含运行应用所需的一切:代码、运行时、系统工具、系统库和设置。
从当前目录的 Dockerfile 构建镜像:
```bash
docker build -t <image_name> .
```
不使用缓存构建镜像:
```bash
docker build -t <image_name> . --no-cache
```
使用指定标签构建(例如 `myapp:v1.2`):
```bash
docker build -t <image_name>:<tag> .
```
列出本地镜像:
```bash
docker images
```
为推送到镜像仓库给镜像打标签:
```bash
docker tag <image> <username>/<image>:<tag>
```
删除镜像:
```bash
docker rmi <image_name>
```
移除悬空(未使用)的镜像:
```bash
docker image prune
```
移除所有未使用的镜像,而不仅仅是悬空镜像:
```bash
docker image prune -a
```
显示镜像的各个层:
```bash
docker history <image_name>
```
## Docker Hub
Docker Hub 是一项用于查找和共享容器镜像的服务。了解更多请访问 https://hub.docker.com
登录 Docker Hub:
```bash
docker login -u <username>
```
登出:
```bash
docker logout
```
在 Docker Hub 中搜索镜像:
```bash
docker search <image_name>
```
从 Docker Hub 拉取镜像:
```bash
docker pull <image_name>
```
拉取指定标签的版本:
```bash
docker pull <image_name>:<tag>
```
将镜像发布到 Docker Hub:
```bash
docker push <username>/<image_name>
```
## 容器
容器是 Docker 镜像的运行时实例。无论基础设施如何,容器都会以相同的方式运行。容器将软件与其环境隔离,确保它在开发、预发布和生产环境中保持一致的运行效果。
### 运行容器
从镜像创建并运行容器:
```bash
docker run <image_name>
```
使用自定义名称运行:
```bash
docker run --name <container_name> <image_name>
```
在后台运行(分离模式):
```bash
docker run -d <image_name>
```
以交互方式运行并进入 shell:
```bash
docker run -it <image_name> bash
```
容器退出时自动移除:
```bash
docker run --rm <image_name>
```
将容器的端口发布到主机:
```bash
docker run -p <host_port>:<container_port> <image_name>
```
设置环境变量:
```bash
docker run -e KEY=value <image_name>
```
从文件加载环境变量:
```bash
docker run --env-file ./env.list <image_name>
```
挂载命名卷:
```bash
docker run -v <volume_name>:/path/in/container <image_name>
```
将当前目录进行绑定挂载:
```bash
docker run -v $(pwd):/app <image_name>
```
设置重启策略(可选值:`no`、`on-failure`、`always`、`unless-stopped`):
```bash
docker run --restart unless-stopped <image_name>
```
连接到指定网络:
```bash
docker run --network <network_name> <image_name>
```
### 管理容器
列出正在运行的容器:
```bash
docker ps
```
列出所有容器(运行中和已停止):
```bash
docker ps -a
```
启动一个已停止的容器:
```bash
docker start <container_name>
```
停止一个正在运行的容器:
```bash
docker stop <container_name>
```
重启容器:
```bash
docker restart <container_name>
```
移除一个已停止的容器:
```bash
docker rm <container_name>
```
强制移除一个正在运行的容器:
```bash
docker rm -f <container_name>
```
移除所有已停止的容器:
```bash
docker container prune
```
重命名容器:
```bash
docker rename <old_name> <new_name>
```
### 检查与交互
进入正在运行容器的 shell:
```bash
docker exec -it <container_name> bash
```
对于不自带 bash 的精简镜像(例如 alpine),使用 `sh`:
```bash
docker exec -it <container_name> sh
```
获取日志:
```bash
docker logs <container_name>
```
持续跟踪日志(类似 `tail -f`):
```bash
docker logs -f <container_name>
```
仅显示最后 100 行:
```bash
docker logs --tail 100 <container_name>
```
显示容器的底层详细信息(JSON):
```bash
docker inspect <container_name>
```
实时查看所有容器的资源使用统计:
```bash
docker stats
```
显示容器内正在运行的进程:
```bash
docker top <container_name>
```
从容器中复制文件出来:
```bash
docker cp <container_name>:/path/in/container ./
```
将文件复制到容器中:
```bash
docker cp ./local_file <container_name>:/path/
```
显示容器启动以来的文件系统变更:
```bash
docker diff <container_name>
```
## 卷
卷(Volume)将数据持久化在容器的可写层之外,因此数据在容器被移除后仍然保留。
创建命名卷:
```bash
docker volume create <volume_name>
```
列出卷:
```bash
docker volume ls
```
显示卷的详细信息:
```bash
docker volume inspect <volume_name>
```
移除卷:
```bash
docker volume rm <volume_name>
```
移除所有未使用的卷:
```bash
docker volume prune
```
将命名卷挂载到容器(由 Docker 管理):
```bash
docker run -v <volume_name>:/data <image_name>
```
将主机路径绑定挂载到容器:
```bash
docker run -v $(pwd):/app <image_name>
```
使用 `--mount` 语法的等价绑定挂载:
```bash
docker run --mount type=bind,src=$(pwd),dst=/app <image_name>
```
## 网络
同一网络中的容器可以通过容器名称相互访问。
列出网络:
```bash
docker network ls
```
创建网络:
```bash
docker network create <network_name>
```
显示网络详细信息:
```bash
docker network inspect <network_name>
```
将正在运行的容器连接到网络:
```bash
docker network connect <network_name> <container_name>
```
将容器从网络断开:
```bash
docker network disconnect <network_name> <container_name>
```
移除网络:
```bash
docker network rm <network_name>
```
移除所有未使用的网络:
```bash
docker network prune
```
## Docker Compose
Compose 通过单个 `compose.yaml`(或 `docker-compose.yml`)文件运行多容器应用。
启动所有服务(前台):
```bash
docker compose up
```
启动所有服务(分离模式):
```bash
docker compose up -d
```
启动前先重新构建镜像:
```bash
docker compose up --build
```
停止并移除容器和网络:
```bash
docker compose down
```
同时移除命名卷:
```bash
docker compose down -v
```
列出项目中的服务:
```bash
docker compose ps
```
持续跟踪所有服务的日志:
```bash
docker compose logs -f
```
持续跟踪单个服务的日志:
```bash
docker compose logs -f <service>
```
构建(或重新构建)服务:
```bash
docker compose build
```
拉取服务镜像:
```bash
docker compose pull
```
在正在运行的服务中打开 shell:
```bash
docker compose exec <service> bash
```
在新容器中运行一次性命令:
```bash
docker compose run --rm <service> <command>
```
重启单个服务:
```bash
docker compose restart <service>
```
校验并查看解析后的 compose 文件:
```bash
docker compose config
```
## 系统与清理
磁盘占用会迅速累积。以下命令可用于回收空间。
显示磁盘使用情况(镜像、容器、卷、构建缓存):
```bash
docker system df
```
移除已停止的容器、悬空镜像和未使用的网络:
```bash
docker system prune
```
同时移除所有未使用的镜像(不仅仅是悬空镜像):
```bash
docker system prune -a
```
同时移除未使用的卷(具有破坏性——运行前请再三确认):
```bash
docker system prune -a --volumes
```
清理构建缓存:
```bash
docker builder prune
```
## 快速参考:常用标志
| 标志 | 含义 |
|------|---------|
| `-d` | 分离模式(在后台运行) |
| `-it` | 交互模式 + TTY(用于 shell) |
| `--rm` | 容器退出时移除它 |
| `-p host:container` | 发布端口 |
| `-v src:dst` | 挂载卷或绑定挂载 |
| `-e KEY=value` | 环境变量 |
| `--name` | 指定容器名称 |
| `--network` | 连接到网络 |
| `--restart` | 重启策略(`no`、`on-failure`、`always`、`unless-stopped`) |
@@ -1,13 +1,36 @@
<script setup lang="ts">
import { ref, watch } from 'vue';
import { useI18n } from 'vue-i18n';
import { useThemeVars } from 'naive-ui';
import Memo from './docker-swarm.md';
import type { Component } from 'vue';
const themeVars = useThemeVars();
const { locale } = useI18n();
const memoImports = import.meta.glob('./docker-swarm*.md');
const memoComponent = ref<Component | null>(null);
async function loadMemo(currentLocale = locale.value) {
const memoKey = `./docker-swarm.${currentLocale}.md`;
const loader = memoImports[memoKey] ?? memoImports['./docker-swarm.md'];
if (!loader) {
memoComponent.value = null;
return;
}
const module = (await loader()) as { default?: Component };
memoComponent.value = module.default ?? module;
}
watch(locale, () => {
loadMemo();
}, { immediate: true });
</script>
<template>
<div>
<Memo style="overflow-x: auto;" />
<component :is="memoComponent" style="overflow-x: auto;" />
</div>
</template>
@@ -0,0 +1,200 @@
**Docker Swarm 模式** 是 Docker 原生的集群与编排解决方案。它允许你将一组 Docker 节点作为一个虚拟系统统一管理,从而实现高可用性、负载均衡以及容器化应用的简化部署。
主要特性:
- 内置编排
- 声明式服务模型
- 滚动更新
- 自动扩缩容与自愈
- 通过 TLS 实现安全的节点通信
## 📌 Swarm 初始化
- **初始化 Swarm**
```bash
docker swarm init
```
- **加入 Swarm(在工作节点/管理节点上)**
```bash
docker swarm join-token worker
```
- **离开 Swarm**
```bash
docker swarm leave
```
- **强制离开(在管理节点上)**
```bash
docker swarm leave --force
```
## 👥 节点管理
- **列出节点**
```bash
docker node ls
```
- **将节点提升为管理节点**
```bash
docker node promote <node-name>
```
- **将节点降级为工作节点**
```bash
docker node demote <node-name>
```
- **查看节点详情**
```bash
docker node inspect <node-name> --pretty
```
- **排空节点(禁止调度)**
```bash
docker node update --availability drain <node-name>
```
- **激活节点**
```bash
docker node update --availability active <node-name>
```
## 🧠 管理节点
管理节点负责:
- 编排任务与服务
- 维护集群状态
- 处理 API 请求
你可以部署多个管理节点以实现高可用性,但任意时刻只有一个是 **leader(领导者)**。
- **查看管理节点状态**
```bash
docker node ls
```
- **查看 Raft 共识信息**
```bash
docker swarm inspect
```
## 📦 服务管理
- **创建服务**
```bash
docker service create --name <service-name> <image>
```
- **创建带副本的服务**
```bash
docker service create --name <service-name> --replicas <n> <image>
```
- **列出服务**
```bash
docker service ls
```
- **查看服务详情**
```bash
docker service inspect <service-name> --pretty
```
- **扩缩容服务**
```bash
docker service scale <service-name>=<n>
```
- **更新服务**
```bash
docker service update --image <new-image> <service-name>
```
- **删除服务**
```bash
docker service rm <service-name>
```
## 🔁 副本(Replicas)
副本定义了某个服务在 Swarm 集群中应运行的实例数量。
- **创建服务时设置副本数**
```bash
docker service create --replicas 5 --name myapp myimage
```
- **扩缩容副本**
```bash
docker service scale myapp=10
```
Swarm 会自动将副本分配到可用的节点上,并在副本失败时自动重启。
## 🐝 任务与容器管理
- **列出服务的任务**
```bash
docker service ps <service-name>
```
- **列出所有任务**
```bash
docker node ps <node-name>
```
- **列出容器**
```bash
docker container ls
```
- **查看容器详情**
```bash
docker container inspect <container-id>
```
## 🌐 网络
### 🧠 什么是覆盖网络(Overlay Network)?
覆盖网络(overlay network)是一种跨越多个 Docker 主机的虚拟网络。它允许运行在不同节点上的容器
### 命令
- **创建覆盖网络**
```bash
docker network create --driver overlay <network-name>
```
- **列出网络**
```bash
docker network ls
```
- **将服务连接到网络**
```bash
docker service create --name <service-name> --network <network-name> <image>
```
## 🛠 常用参数
| 参数 | 说明 |
|------|------|
| `--replicas` | 服务实例的数量 |
| `--publish` | 端口映射(`<host>:<container>`) |
| `--mount` | 卷挂载 |
| `--constraint` | 节点放置规则 |
| `--update-delay` | 更新之间的延迟 |
| `--limit-cpu` / `--limit-memory` | 资源限制 |
## 📄 示例:创建一个 Web 服务
```bash
docker service create \
--name web \
--replicas 3 \
--publish 80:80 \
--network webnet \
nginx
```
+25 -2
View File
@@ -1,13 +1,36 @@
<script setup lang="ts">
import { ref, watch } from 'vue';
import { useI18n } from 'vue-i18n';
import { useThemeVars } from 'naive-ui';
import Memo from './dockerfile.md';
import type { Component } from 'vue';
const themeVars = useThemeVars();
const { locale } = useI18n();
const memoImports = import.meta.glob('./dockerfile*.md');
const memoComponent = ref<Component | null>(null);
async function loadMemo(currentLocale = locale.value) {
const memoKey = `./dockerfile.${currentLocale}.md`;
const loader = memoImports[memoKey] ?? memoImports['./dockerfile.md'];
if (!loader) {
memoComponent.value = null;
return;
}
const module = (await loader()) as { default?: Component };
memoComponent.value = module.default ?? module;
}
watch(locale, () => {
loadMemo();
}, { immediate: true });
</script>
<template>
<div>
<Memo style="overflow-x: auto;" />
<component :is="memoComponent" style="overflow-x: auto;" />
</div>
</template>
+258
View File
@@ -0,0 +1,258 @@
**Dockerfile** 是一个由指令组成的脚本,用于构建 Docker 镜像。每条指令都会在镜像中创建一个层。
## 📦 基本结构
```Dockerfile
# 注释
INSTRUCTION arguments
```
## 🚀 核心指令
### `FROM`
指定基础镜像。
```Dockerfile
FROM ubuntu:20.04
FROM node:22-alpine
```
### `LABEL`
为镜像添加元数据。
```Dockerfile
LABEL maintainer="you@example.com"
LABEL version="1.0" description="My App"
```
### `ENV`
设置环境变量。
```Dockerfile
ENV NODE_ENV=production
ENV PATH="/app/bin:$PATH"
```
### `RUN`
在构建过程中于 shell 中执行命令。
```Dockerfile
RUN apt-get update && apt-get install -y curl
RUN npm install
```
使用 `RUN ["executable", "param1", "param2"]` 以 JSON 数组形式书写。
### `COPY`
将文件从主机复制到镜像中。
```Dockerfile
COPY . /app
COPY config.json /app/config.json
```
### `ADD`
类似于 `COPY`,但支持远程 URL 并可自动解压归档文件。
```Dockerfile
ADD https://example.com/file.tar.gz /app/
ADD archive.zip /app/
```
### `CMD`
设置容器启动时运行的默认命令。
```Dockerfile
CMD ["node", "server.js"] # 推荐的 exec 形式
CMD node server.js # shell 形式
```
只允许一条 `CMD`;后面的会覆盖前面的。
### `ENTRYPOINT`
将容器配置为可执行程序运行。
```Dockerfile
ENTRYPOINT ["python", "app.py"]
```
与 `CMD` 搭配使用可传递默认参数。
### `WORKDIR`
为后续指令设置工作目录。
```Dockerfile
WORKDIR /app
```
### `EXPOSE`
声明容器监听的端口。
```Dockerfile
EXPOSE 80
EXPOSE 443
```
注意:这并不会发布端口。
### `VOLUME`
为持久化或共享数据创建挂载点。
```Dockerfile
VOLUME ["/data"]
```
### `USER`
设置运行后续指令的用户。
```Dockerfile
USER appuser
```
### `ARG`
定义构建时变量。
```Dockerfile
ARG VERSION=1.0
RUN echo $VERSION
```
在 `docker build` 时使用 `--build-arg VERSION=2.0`。
### `ONBUILD`
当该镜像被用作基础镜像时触发相应指令。
```Dockerfile
ONBUILD COPY . /app
```
## 🧠 最佳实践
- 使用精简的基础镜像(例如 `alpine`)以减小体积。
- 合并 `RUN` 命令以减少层数。
- 使用 `.dockerignore` 排除不必要的文件。
- 除非需要解压归档,否则优先使用 `COPY` 而非 `ADD`。
- 使用 `ENTRYPOINT` 定义固定命令,使用 `CMD` 传递参数。
- 避免硬编码密钥或凭据。
## 🧪 示例 Dockerfile
```Dockerfile
FROM node:22-alpine
LABEL maintainer="guillaume@example.com"
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
ENV NODE_ENV=production
CMD ["node", "index.js"]
```
## 🛠️ 构建与运行
```bash
# 构建镜像
docker build -t my-app .
# 运行容器
docker run -p 3000:3000 my-app
```
## 📁 .dockerignore 示例
```plaintext
node_modules
*.log
Dockerfile
.git
```
## 🏗️ 多阶段构建
**多阶段构建**允许你在一个 Dockerfile 中使用多条 `FROM` 语句,以优化镜像体积并将构建依赖与运行时分离。
### 🎯 为什么使用多阶段构建?
- 通过排除构建工具和中间文件来减小最终镜像体积。
- 通过最小化攻击面来提升安全性。
- 保持 Dockerfile 简洁且易于维护。
### 🧱 基本语法
```Dockerfile
# 阶段 1:构建
FROM node:22-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
# 阶段 2:生产
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
```
### 🏷️ 命名阶段
你可以使用 `AS <name>` 为每个阶段命名,并在之后通过 `--from=<name>` 引用它。
```Dockerfile
FROM golang:1.21 AS build
WORKDIR /src
COPY . .
RUN go build -o myapp
FROM alpine:latest
COPY --from=build /src/myapp /usr/local/bin/myapp
ENTRYPOINT ["myapp"]
```
### 📦 复制构建产物
使用 `COPY --from=<stage>` 将文件从一个阶段复制到另一个阶段。
```Dockerfile
COPY --from=builder /app/output /app/output
```
你可以复制:
- 文件
- 目录
- 二进制文件
- 配置
### 🧼 精简的最终镜像
多阶段构建可帮助你避免臃肿的镜像:
```Dockerfile
# 不使用多阶段:包含编译器、源代码等
# 使用多阶段:仅包含运行时必需项
```
### 🧪 实战示例:React 应用
```Dockerfile
# 构建阶段
FROM node:22 AS build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
# 服务阶段
FROM nginx:alpine
COPY --from=build /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]
```