remove:docker

2025-08-01 09:19:32 -04:00 · 2025-03-24 09:04:48 +08:00
parent 079f5a7108
commit a927d95730
9 changed files with 0 additions and 1338 deletions
--- a/content/learn-docker-1.md
+++ b/content/learn-docker-1.md
@ -1,87 +0,0 @@
 +++
 title = "Docker学习笔记(一)"
 date = 2024-03-25
 [taxonomies]
 tags = ["学习笔记"]
 +++
 前言 Docker 是一个开源平台，通过将应用程序隔离到轻量级、可移植的容器中，自动执行应用程序的部署、扩展和管理。容器是独立的可执行单元，它封装了应用程序在各种环境中一致运行所需的所有必要依赖项、库和配置文件。
 <!-- more -->
 ## **什么是容器？**
 容器是轻量级、可移植和隔离的软件环境，允许开发人员跨不同平台一致地运行和打包应用程序及其依赖项。它们有助于简化应用程序开发、部署和管理流程，同时确保应用程序始终如一地运行，而不管底层基础架构如何。
 ## **容器是如何工作的？**
 与传统的虚拟化不同，传统的虚拟化使用硬件资源模拟完整的操作系统，容器共享主机的操作系统内核，并利用轻量级虚拟化技术来创建隔离的进程。这种方法有几个好处，包括：
 - 效率：容器的开销较小，可以共享公共库和可执行文件，与虚拟机 （VM） 相比，可以在单个主机上运行更多容器。
 - 可移植性：容器封装了应用程序及其依赖项，因此可以轻松地在不同的环境和平台上一致地移动和运行它们。
 - 快速启动：由于容器不需要启动完整的操作系统，因此它们的启动和关闭速度比 VM 快得多。
 - 一致性：容器为应用程序的开发、测试和生产阶段提供了一致的环境，从而减少了“它在我的机器上工作”的问题。
 ## **容器和 Docker**
 Docker 是一个简化创建、部署和管理容器过程的平台。它为开发人员和管理员提供了一组工具和 API 来管理容器化应用程序。使用 Docker，您可以将应用程序代码、库和依赖项构建并打包到容器映像中，该映像可以在任何支持 Docker 的环境中一致地分发和运行。
 ## **对容器的需求**
 在软件开发和部署领域，一致性和效率至关重要。在容器出现之前，开发人员在跨不同环境部署应用程序时经常面临挑战，包括：
 - 不一致的环境：开发人员通常在不同的环境中工作，与生产服务器相比，这些环境可能具有不同的配置和库。这会导致部署应用程序时出现兼容性问题。
 - 资源利用效率低下：虚拟机 （VM） 被广泛用于克服环境不一致的问题。但是，VM 需要为每个应用程序运行整个操作系统，从而使资源利用率低效。
 - 流程缓慢和可伸缩性问题：传统的部署方法具有较慢的上市时间和扩展困难，这阻碍了软件更新的快速交付。
 ## **容器如何应对这些挑战：**
 - 一致的环境：容器通过将应用程序及其依赖项、配置和库捆绑到单个容器中来解决环境不一致问题。这保证了应用程序在不同环境中平稳运行。
 - 高效利用资源：与虚拟机不同，容器共享底层系统资源和操作系统内核，这使得它们轻量级且高效。容器旨在使用更少的资源并更快地启动，从而提高资源利用率。
 - 更快的流程和可扩展性：容器可以轻松创建、销毁和替换，从而加快开发和部署周期。由于可以在不消耗大量资源的情况下部署多个容器，因此扩展应用程序变得更加容易。
 总体而言，对于希望快速响应市场变化、提高资源效率并确保可靠和一致的软件交付的组织来说，容器已成为必不可少的工具。它们彻底改变了现代软件开发实践，并在部署和应用程序管理领域产生了持久的影响。
 ## **裸机、虚拟机、容器**
 - 裸机
 裸机是一个术语，用于描述直接在硬件上运行的计算机，无需任何虚拟化。这是运行应用程序的高性能方式，但也是最不灵活的方式。每台服务器只能运行一个应用程序，并且不能轻松地将应用程序移动到另一台服务器。
 - 虚拟机
 虚拟机 （VM） 是一种在单个服务器上运行多个应用程序的方法。每个 VM 都运行在虚拟机监控程序之上，虚拟机监控程序是模拟计算机硬件的软件。虚拟机监控程序允许您在单个服务器上运行多个操作系统，并且它还在不同 VM 上运行的应用程序之间提供隔离。
 - 容器
 容器是一种在单个服务器上运行多个应用程序的方法，而不会产生虚拟机管理程序的开销。每个容器都运行在容器引擎之上，容器引擎是一种模拟计算机操作系统的软件。容器引擎允许您在单个服务器上运行多个应用程序，它还提供在不同容器上运行的应用程序之间的隔离。
 **Docker 与 OCI**
 开放容器计划 （OCI） 是 Linux 基金会的一个项目，旨在为容器格式和运行时创建行业标准。其主要目标是通过定义的技术规范确保容器环境的兼容性和互操作性。
 Docker 是 OCI 的创始成员之一，在制定容器格式和运行时标准方面发挥了关键作用。Docker 最初开发了容器运行时（Docker 引擎）和映像格式（Docker 映像），作为 OCI 规范的基础。
 **OCI 规范**
 OCI 有两个主要规范：
 - 运行时规范 （runtime-spec）：它定义了通过隔离技术（如容器引擎）执行容器的规范。Docker 构建的容器运行时（称为“containerd”）指导了 OCI 运行时规范的开发。
 - 镜像规范 （image-spec）：它定义容器镜像格式，用于描述容器的内容，并可由兼容的运行时运行。Docker 的初始映像格式促成了 OCI 映像规范的创建。
 ## **Docker 和 OCI 之间的兼容性**
 Docker 始终致力于支持 OCI 规范，并且自参与 OCI 以来，不断更新其软件以符合 OCI 标准。Docker 的 containerd 运行时和映像格式与 OCI 规范完全兼容，使 Docker 容器能够由其他符合 OCI 标准的容器运行时运行，反之亦然。
 总之，Docker 和 Open Container Initiative 共同致力于维护容器行业的标准化和兼容性。Docker 在 OCI 规范的制定中发挥了重要作用，确保容器生态系统保持健康、可互操作，并可供整个行业的广泛用户和平台访问。
--- a/content/learn-docker-2.md
+++ b/content/learn-docker-2.md
@ -1,103 +0,0 @@
 +++
 title = "Docker学习笔记(二)"
 date = 2024-03-26
 [taxonomies]
 tags = ["学习笔记"]
 +++
 前言 了解支持 Docker 的核心技术将有助于更深入地了解 Docker 的工作原理，并更有效地使用该平台。
 <!-- more -->
 ## **Linux 容器 （LXC）**
 Linux 容器 （LXC） 是 Docker 的基础。LXC 是一种轻量级虚拟化解决方案，它允许多个隔离的 Linux 系统在单个主机上运行，而无需成熟的虚拟机管理程序。LXC 以安全和优化的方式有效地隔离应用程序及其依赖项。
 ## **控制组 （cgroups）**
 控制组 （cgroups） 是一项 Linux 内核功能，允许将 CPU、内存和 I/O 等资源分配给一组进程并对其进行管理。Docker 利用 cgroups 来限制容器使用的资源，并确保一个容器不会垄断主机系统的资源。
 ## **联合文件系统 （UnionFS）**
 UnionFS 是一种文件系统服务，允许在单个统一视图中叠加多个文件系统。Docker 使用 UnionFS 为镜像和容器创建分层方法，从而实现更好的通用文件共享和更快的容器创建。
 ## **命名空间**
 命名空间是 Docker 用于在容器之间提供隔离的核心技术之一。在本节中，我们将简要讨论什么是命名空间以及它们是如何工作的。
 在 Linux 内核中，命名空间是一种允许隔离各种系统资源的功能，使进程及其子进程能够查看与其他进程分开的系统子集。命名空间有助于创建抽象层，以使容器化进程彼此分离并与主机系统分离。
 Linux 中有几种类型的命名空间，包括：
 - PID（进程 ID）：隔离进程 ID 号空间，这意味着容器中的进程只能看到自己的进程，而看不到主机或其他容器中的进程。
 - 网络 （NET）：为每个容器提供单独的网络堆栈视图，包括其自己的网络接口、路由表和防火墙规则。
 - 挂载 （MNT）：隔离文件系统挂载点，使每个容器都有自己的根文件系统，并且挂载的资源仅显示在该容器中。
 - UTS（UNIX 分时系统）：允许每个容器拥有自己的主机名和域名，与其他容器和主机系统分开。
 - 用户 （USER）：在容器和主机之间映射用户和组标识符，以便可以为容器中的资源设置不同的权限。
 - IPC（进程间通信）：允许或限制不同容器中进程之间的通信。
 ## **Docker如何使用命名空间**
 Docker 使用命名空间为容器创建隔离环境。启动容器时，Docker 会为该容器创建一组新的命名空间。这些命名空间仅适用于容器内，因此在容器内运行的任何进程都可以访问与其他容器以及主机系统隔离的系统资源子集。
 Docker 容器和 LXC 容器很相似，所提供的安全特性也差不多。当用 docker run 启动一个容器时，在后台 Docker 为容器创建了一个独立的命名空间和控制组集合。
 命名空间提供了最基础也是最直接的隔离，在容器中运行的进程不会被运行在主机上的进程和其它容器发现和作用。
 每个容器都有自己独有的网络栈，意味着它们不能访问其他容器的 sockets 或接口。不过，如果主机系统上做了相应的设置，容器可以像跟主机交互一样的和其他容器交互。当指定公共端口或使用 links 来连接 2 个容器时，容器就可以相互通信了（可以根据配置来限制通信的策略）。
 从网络架构的角度来看，所有的容器通过本地主机的网桥接口相互通信，就像物理机器通过物理交换机通信一样。
 那么，内核中实现命名空间和私有网络的代码是否足够成熟？
 内核命名空间从 2.6.15 版本（2008 年 7 月发布）之后被引入，数年间，这些机制的可靠性在诸多大型生产系统中被实践验证。
 实际上，命名空间的想法和设计提出的时间要更早，最初是为了在内核中引入一种机制来实现 OpenVZ 的特性。 而 OpenVZ 项目早在 2005 年就发布了，其设计和实现都已经十分成熟。
 通过利用命名空间，Docker 确保容器是真正可移植的，并且可以在任何系统上运行，而不会受到同一主机上运行的其他进程或容器的冲突或干扰。
 ## **控制组**
 cgroups 或控制组是一项 Linux 内核功能，负责实现资源的审计和限制。
 它提供了很多有用的特性；以及确保各个容器可以公平地分享主机的内存、CPU、磁盘 IO 等资源；当然，更重要的是，控制组确保了当容器内的资源使用产生压力时不会连累主机系统。
 尽管控制组不负责隔离容器之间相互访问、处理数据和进程，它在防止拒绝服务（DDOS）攻击方面是必不可少的。尤其是在多用户的平台（比如公有或私有的 PaaS）上，控制组十分重要。例如，当某些应用程序表现异常的时候，可以保证一致地正常运行和性能。
 控制组机制始于 2006 年，内核从 2.6.24 版本开始被引入。
 - 资源隔离
 cgroups 有助于将每个容器限制在一组特定的资源中，从而确保多个容器之间公平共享系统资源。这样可以更好地隔离不同容器，因此行为异常的容器不会消耗所有可用资源，从而对其他容器产生负面影响。
 - 限制资源
 使用 cgroups，可以对容器使用的各种系统资源（如 CPU、内存和 I/O）设置限制。这有助于防止单个容器消耗过多资源并导致其他容器或主机系统的性能问题。
 - 确定容器的优先级
 通过分配不同的资源份额，cgroups 允许您为某些容器提供优先级或优先级。在某些容器比其他容器更关键的情况下，或者在资源争用高的情况下，这可能很有用。
 - Monitoring 监测
 cGroups 还提供用于监视单个容器的资源使用情况的机制，这有助于深入了解容器性能并识别潜在的资源瓶颈。
 ## **Union Filesystems 联合文件系统**
 联合文件系统，也称为 UnionFS，在 Docker 的整体功能中起着至关重要的作用。联合文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。它是一种独特的文件系统类型，它通过覆盖多个目录来创建虚拟的分层文件结构。UnionFS 无需修改原始文件系统或合并目录，而是支持将多个目录同时挂载到单个挂载点上，同时保持其内容独立。此功能在 Docker 的上下文中特别有用，因为它允许我们通过最小化重复和减小容器映像大小来管理和优化存储性能。
 以下是联合文件系统的一些基本特性：
 - 分层结构：UnionFS 构建了一个分层结构，该结构由多个只读层和一个顶部可写层组成。此结构通过仅更新可写层来有效处理更改，而只读层保留原始数据。
 - Copy-on-Write：COW 机制是 UnionFS 不可或缺的功能。如果容器对现有文件进行更改，系统将在可写层中创建该文件的副本，而只读层中的原始文件保持不变。此过程将修改限制在最顶层，确保快速且资源节约的操作。
 - 资源共享：联合文件系统允许多个容器在单独运行时共享公共基础层。此功能可防止资源重复并节省大量存储空间。
 - 快速容器初始化：联合文件系统只需在现有只读层上创建新的可写层，就可以立即创建新容器。这种快速初始化减少了重复文件操作的开销，最终提高了性能。
 ## **Docker 中流行的联合文件系统**
 Docker 支持多个联合文件系统，便于构建和管理容器。一些流行的选项包括：
 - AUFS（高级多层统一文件系统）：AUFS 被广泛用作 Docker 存储驱动程序，可实现多层的高效管理。
 - OverlayFS（Overlay Filesystem）：OverlayFS 是 Docker 支持的另一个联合文件系统。与 AUFS 相比，它使用简化的方法来创建和管理覆盖目录。
 - Btrfs（B-Tree 文件系统）：Btrfs 是一种现代文件系统，除了快照和校验和等高级存储功能外，还提供与联合文件系统的兼容性。
 - ZFS（Z 文件系统）：ZFS 是一个高容量且强大的存储平台，它提供联合文件系统功能以及数据保护、压缩和重复数据删除。
--- a/content/learn-docker-3.md
+++ b/content/learn-docker-3.md
@ -1,174 +0,0 @@
 +++
 title = "Docker学习笔记(三)"
 date = 2024-03-27
 [taxonomies]
 tags = ["学习笔记"]
 +++
 前言 Docker 是一个平台，可简化在轻量级、可移植容器中构建、打包和部署应用程序的过程。在本节中，我们将介绍 Docker 的基础知识、其组件以及入门所需的关键命令。
 <!-- more -->
 ## **基础知识**
 Docker 是一个平台，可简化在轻量级、可移植容器中构建、打包和部署应用程序的过程。在本节中，我们将介绍 Docker 的基础知识、其组件以及入门所需的关键命令。
 ## **什么是容器？**
 容器是一个轻量级、独立且可执行的软件包，其中包含运行应用程序所需的所有依赖项（库、二进制文件和配置文件）。容器将应用程序与其环境隔离开来，确保它们在不同系统中一致地工作。
 ## **Docker 生态系统中有三个关键组件：**
 - Dockerfile：包含用于构建 Docker 映像的指令（命令）的文本文件。
 - Docker 映像：从 Dockerfile 创建的容器快照。映像存储在注册表（如 Docker Hub）中，可以拉取或推送到注册表。
 - Docker 容器：Docker 映像的运行实例。
 ## **安装Docker**
 **安装基础工具**
 ```
 sudo apt-get update
 sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg \
    lsb-release
 ```
 **安装docker的gpg key：**
 ```
 curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
 ```
 **安装docker源**
 ```
 echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
 ```
 上面命令中的 lsb_release -cs 返回 bullseye ，也就是debian11的代号。
 **安装docker**
 ```
 apt-get update
 sudo apt-get install docker-ce docker-ce-cli containerd.io
 sudo systemctl enable docker
 sudo systemctl start docker
 ```
 至此安装完成。
 在debian系的Linux发行版上，docker会开机启动启动。
 如果平时使用非root账户，又不想每次执行docker命令之前都加上sudo，参考docker的 文档 ，可以添加 docker 组，并将非root账户加入到该组中。下面的命令创建 docker 组并将当前用户加入 docker 组，执行完成之后重新登陆生效：
 ```
 sudo groupadd docker
 sudo usermod -aG docker $USER
 ```
 **使用 Docker 存储库安装**
 我建议使用此方法的主要原因是您可以轻松升级，因为存储库可以轻松更新！
 首先，使用以下命令安装此方法的先决条件：
 ```
 sudo apt update && sudo apt install ca-certificates curl gnupg
 ```
 现在，让我们使用以下命令创建一个目录来存储密钥环：
 ```
 sudo install -m 0755 -d /etc/apt/keyrings
 ```
 接下来，使用给定的命令下载 GPG 密钥并将其存储在  /etc/apt/keyrings/etc/apt/keyrings  目录中：
 ```
 curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
 ```
 完成后，使用 chmod 命令更改 docker.gpg 文件的权限：
 ```
 sudo chmod a+r /etc/apt/keyrings/docker.gpg
 ```
 最后，使用以下命令为 Docker 设置存储库：
 ```
 echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
 ```
 上述命令中每行末尾的额外  \  只是添加新行的一种方式，以便您可以轻松查看整个命令。就是这样！
 现在，您可以使用以下命令更新存储库索引并安装 Docker：
 ```
 sudo apt update && sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
 ```
 要验证 Docker 安装，您可以安装 hello-world 映像：
 ```
 sudo docker run hello-world
 ```
 hello-world docker 镜像很小，仅用于检查 Docker 是否运行正常。
 ## **使用 Docker 而不使用 sudo**
 如果您注意到，在运行 hello-world 映像时，我使用了 sudo。
 这可能不太方便。那么如何将其配置为不必使用 sudo 呢？
 首先使用 groupadd 命令创建一个 docker 组：
 ```
 sudo groupadd docker
 ```
 现在，将用户添加到组（docker）：
 ```
 sudo usermod -aG docker $USER
 ```
 现在从终端注销并重新登录以使更改生效。
 如果您在虚拟机中安装 Docker，需要重新启动才能使您所做的更改生效。
 让我们通过运行 hello-world 图像来测试它：
 ```
 docker run hello-world
 ```
 正如您所看到的，我无需使用 sudo 即可获得相同的结果。
 ## **卸载 Docker**
 首先，使用以下命令停止 docker 服务：
 ```
 sudo systemctl stop docker
 ```
 然后按以下方式使用 apt purge 命令从系统中删除 Docker：
 ```
 sudo apt purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin 
 ```
 如果您打算进行全新安装或者不想拥有任何以前的数据，那么您可以使用 rm 命令删除 Docker 文件：
 ```
 sudo rm -rf /var/lib/docker
 ```
 ```
 sudo rm -rf /var/lib/containerd
 ```
 就是这样！ Docker 已成功删除。
 ## **Docker Commands Docker 命令**
 ```
 docker pull <image>：                   从注册表（如 Docker Hub）下载映像。
 docker build -t <image_name> <path>：   从 Dockerfile 构建映像，其中 <path> 是包含 Dockerfile 的目录。
 docker image ls：                       列出本地计算机上可用的所有映像。
 docker run -d -p <host_port>:<container_port> --name <container_name> <image>：从映像运行容器，将主机端口映射到容器端口。
 docker container ls：                   列出所有正在运行的容器。
 docker container stop <container>：     停止正在运行的容器。
 docker container rm <container>：       移除停止的容器。
 docker image rm <image>：               从本地计算机中删除映像。
 ```
--- a/content/learn-docker-4.md
+++ b/content/learn-docker-4.md
@ -1,78 +0,0 @@
 +++
 title = "Docker学习笔记(四)"
 date = 2024-03-28
 [taxonomies]
 tags = ["学习笔记"]
 +++
 前言 Docker 使您能够运行与主机操作系统分离的隔离代码段（包括应用程序及其依赖项）的容器。默认情况下，容器是临时的，这意味着容器中存储的任何数据一旦终止就会丢失。为了克服这个问题并跨容器生命周期保留数据，Docker 提供了多种数据持久化方法。
 <!-- more -->
 ## **Docker 中的数据持久化**
 在本节中，我们将介绍：
 - Docker Volumes Docker 卷
 - Bind Mounts 绑定挂载
 - Docker tmpfs mounts Docker tmpfs 挂载
 ## **Docker Volumes Docker 卷**
 Docker 卷是保存 Docker 容器生成和使用的数据的首选方法。卷是 Docker 用于存储文件和目录的主机上的一个目录，这些文件和目录的寿命可能超过容器的生命周期。Docker 卷可以在容器之间共享，它们提供了各种好处，例如轻松备份和数据迁移。
 要创建卷，请使用以下命令：
 ```
 docker volume create volume_name
 ```
 要使用卷，请在 docker run 命令中添加 --volume（或 -v）标志：
 ```
 docker run --volume volume_name:/container/path image_name
 ```
 **在容器中挂载卷**
 若要将卷装载到容器，需要在运行容器时使用 -v 或 --mount 标志。下面是一个示例：
 Using -v flag: 使用 -v 标志：
 ```
 docker run -d -v my-volume:/data your-image
 ```
 Using --mount flag: 使用 --mount 标志：
 ```
 docker run -d --mount source=my-volume,destination=/data your-image
 ```
 在上面的两个示例中，my-volume 是我们之前创建的卷的名称，/data 是容器内将挂载卷的路径。
 **在容器之间共享卷**
 要在多个容器之间共享卷，只需在多个容器上挂载相同的卷即可。下面介绍如何在运行不同映像的两个容器之间共享 my-volume：
 ```
 docker run -d -v my-volume:/data1 image1
 docker run -d -v my-volume:/data2 image2
 ```
 在此示例中，image1 和 image2 将有权访问存储在 my-volume 中的相同数据。
 **Removing a Volume 删除卷**
 要删除卷，可以使用 docker volume rm 命令，后跟卷名称：
 ```
 docker volume rm my-volume
 ```
 ## **Bind Mounts 绑定挂载**
 绑定挂载允许您将主机上的任何目录映射到容器中的目录。此方法在需要修改主机系统上的文件的开发环境中非常有用，并且这些更改应立即在容器中可用。
 与卷相比，绑定挂载的功能有限。使用绑定挂载时，主机上的文件或目录将装载到容器中。文件或目录由其在主机上的绝对路径引用。相比之下，当您使用卷时，会在主机上的 Docker 存储目录中创建一个新目录，Docker 管理该目录的内容。
 文件或目录不需要已存在于 Docker 主机上。如果尚不存在，则按需创建。绑定挂载的性能非常高，但它们依赖于主机的文件系统，该文件系统具有特定的可用目录结构。
 要创建绑定挂载，请在 docker run 命令中使用带有 type=bind 的 --mount 标志：
 ```
 docker run --mount type=bind,src=/host/path,dst=/container/path image_name
 ```
 ## **Docker tmpfs mounts Docker tmpfs 挂载**
 Docker tmpfs 挂载允许您直接在容器的内存中创建临时文件存储。存储在 tmpfs 挂载中的数据快速且安全，但一旦容器终止，数据就会丢失。
 要使用 tmpfs 挂载，请在 docker run 命令中添加 --tmpfs 标志：
 ```
 docker run --tmpfs /container/path image_name
 ```
 通过采用这些方法，可以确保跨容器生命周期的数据持久性，从而增强 Docker 容器的实用性和灵活性。请记住选择最适合您的用例的方法，无论是首选的 Docker 卷、方便的绑定挂载，还是快速安全的 tmpfs 挂载。
--- a/content/learn-docker-5.md
+++ b/content/learn-docker-5.md
@ -1,132 +0,0 @@
 +++
 title = "Docker学习笔记(五)"
 date = 2024-03-29
 [taxonomies]
 tags = ["学习笔记"]
 +++
 前言 第三方映像是预构建的 Docker 容器映像，可在 Docker Hub 或其他容器注册表上使用。这些映像由个人或组织创建和维护，可用作容器化应用程序的起点。
 <!-- more -->
 ## **查找第三方镜像**
 Docker Hub 是最大、最受欢迎的容器镜像注册表，包含官方和社区维护的镜像。您可以根据要使用的名称或技术搜索镜像。
 例如：如果你正在寻找 Node.js 映像，你可以在 Docker Hub 上搜索“Node”，你会找到官方Node.js映像以及许多其他社区维护的映像。
 **在 Dockerfile 中使用映像**
 要在 Dockerfile 中使用第三方映像，只需使用 FROM 指令将映像名称设置为基础映像即可。下面是使用官方Node.js镜像的示例：
 FROM node:14
 ```
 # The rest of your Dockerfile...
 ```
 **注意安全问题**
 请记住，第三方映像可能存在安全漏洞或配置错误。在生产中使用镜像之前，请务必验证镜像的来源并检查其信誉。更喜欢使用官方镜像或维护良好的社区镜像。
 **维护您的镜像**
 使用第三方映像时，必须保持更新，以包含最新的安全更新和依赖项更改。定期检查基础映像中的更新，并相应地重新生成应用程序容器。
 ## **使用第三方映像：数据库**
 在 Docker 容器中运行数据库有助于简化开发过程并简化部署。Docker Hub 为 MySQL、PostgreSQL 和 MongoDB 等流行数据库提供了大量预制映像。
 **示例：使用 MySQL 镜像**
 要使用 MySQL 数据库，请在 Docker Hub 上搜索官方镜像：
 ```
 docker search mysql
 ```
 找到官方图片，然后拉动它：
 ```
 docker pull mysql
 ```
 现在，您可以运行 MySQL 容器。指定所需的环境变量，例如 MYSQL_ROOT_PASSWORD，并选择性地将容器的端口映射到主机：
 ```
 docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -p 3306:3306 -d mysql
 ```
 此命令创建一个名为 some-mysql 的新容器，将 root 密码设置为 my-secret-pw，并将主机上的端口 3306 映射到容器上的端口 3306。
 **示例：使用 PostgreSQL 镜像**
 对于 PostgreSQL，请执行与上述步骤类似的步骤。首先，搜索官方图片：
 ```
 docker search postgres
 ```
 Pull the image: 拉取图像：
 ```
 docker pull postgres
 ```
 运行 PostgreSQL 容器，指定环境变量，例如 POSTGRES_PASSWORD：
 ```
 docker run --name some-postgres -e POSTGRES_PASSWORD=my-secret-pw -p 5432:5432 -d postgres
 ```
 ## **使用 Docker 的交互式测试环境**
 Docker 允许您创建隔离的一次性环境，这些环境可以在完成测试后删除。这使得使用第三方软件、测试不同的依赖项或版本以及快速试验变得更加容易，而不会损坏本地设置。
 **使用 Docker 创建交互式测试环境**
 为了演示如何设置交互式测试环境，让我们以 Python 编程语言为例。我们将使用 Docker Hub 上提供的公共 Python 映像。
 要使用 Python 映像启动交互式测试环境，只需运行以下命令：
 ```
 docker run -it --rm python
 ```
 在这里，-it 标志确保使用 tty 在交互模式下运行容器，而 --rm 标志将在容器停止后将其删除。
 现在，您应该位于容器内的交互式 Python shell 中。您可以像往常一样使用 pip 执行任何 Python 命令或安装其他软件包。
 ```
 print("Hello, Docker!")
 ```
 完成交互式会话后，只需键入 exit() 或按 CTRL+D 即可退出容器。容器将按照 --rm 标志的指定自动删除。
 **交互式测试环境的更多示例**
 可以使用 Docker Hub 上提供的多个第三方映像，并创建各种交互式环境，例如：
 Node.js：若要启动交互式 Node.js shell，可以使用以下命令：
 ```
 docker run -it --rm node
 ```
 Ruby：要启动交互式 Ruby shell，您可以使用以下命令：
 ```
 docker run -it --rm ruby
 ```
 MySQL：要启动临时 MySQL 实例，您可以使用以下命令：
 ```
 docker run -it --rm --name temp-mysql -e MYSQL_ALLOW_EMPTY_PASSWORD=yes -p 3306:3306 mysql
 ```
 这将启动一个临时的MySQL服务器，该服务器可以通过主机端口3306访问。一旦容器停止，它将被移除。
 随意探索和测试各种软件，而不必担心损坏本地计算机或安装不必要的依赖项。将 Docker 用于交互式测试环境可以让您在处理各种第三方软件时更高效、更干净地工作。
 ## **命令行实用程序**
 Docker 映像可以包括命令行实用程序或我们可以在容器内运行的独立应用程序。这在使用第三方映像时非常有用，因为我们想要使用的工具已经打包好，无需任何安装或配置即可运行。
 **BusyBox**
 BusyBox 是一个小型 （1-2 Mb） 且简单的命令行应用程序，它提供了大量常用的 Unix 实用程序，例如 awk、grep、vi 等。要在 Docker 容器中运行 BusyBox，只需拉取映像并使用 Docker 运行它：
 ```
 docker pull busybox
 docker run -it busybox /bin/sh
 ```
 进入容器后，您可以开始运行各种 BusyBox 实用程序，就像在常规命令行上一样。
 **cURL**
 cURL 是一个众所周知的命令行工具，可用于使用各种网络协议传输数据。它通常用于测试 API 或从 Internet 下载文件。若要在 Docker 容器中使用 cURL，可以使用 Docker Hub 上提供的官方 cURL 映像：
 ```
 docker pull curlimages/curl
 docker run --rm curlimages/curl https://example.com
 ```
 在此示例中，--rm 标志用于在命令运行完毕后删除容器。当您只需要运行单个命令，然后清理容器时，这很有用。
 **其他命令行实用程序**
 Docker 映像中提供了许多命令行实用程序，包括但不限于：
 - wget：用于从 Web 上非交互式下载文件的免费实用程序。
 - imagemagick：用于图像处理和转换的强大软件套件。
 - jq：轻量级且灵活的命令行 JSON 处理器。
 若要使用这些工具中的任何一个，可以在 Docker Hub 上搜索它们，并按照其各自存储库中提供的说明进行操作。
--- a/content/learn-docker-6.md
+++ b/content/learn-docker-6.md
@ -1,190 +0,0 @@
 +++
 title = "Docker学习笔记(六)"
 date = 2024-03-30
 [taxonomies]
 tags = ["学习笔记"]
 +++
 前言 容器映像是可执行包，其中包含运行应用程序所需的所有内容：代码、运行时、系统工具、库和设置。通过构建自定义映像，您可以在任何 Docker 支持的平台上无缝部署应用程序及其所有依赖项。
 <!-- more -->
 ## **Dockerfile**
 构建容器镜像的关键组件是 Dockerfile。它本质上是一个脚本，其中包含有关如何组装 Docker 映像的说明。Dockerfile 中的每条指令都会在映像中创建一个新图层，从而更轻松地跟踪更改并最小化映像大小。下面是 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
 COPY . /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"]
 ```
 ## **Building an Image 构建映像**
 创建 Dockerfile 后，可以使用 docker build 命令生成映像。在包含 Dockerfile 的目录中的终端中执行以下命令：
 ```
 docker build -t your-image-name .
 ```
 此命令告诉 Docker 使用当前目录 （.） 中的 Dockerfile 构建映像，并为其分配名称 （-t your-image-name）。
 检查镜像和图层
 成功构建后，可以使用 docker image 命令检查创建的映像：
 ```
 docker image ls
 ```
 要仔细查看镜像的各个图层，请使用 docker history 命令：
 ```
 docker history your-image-name
 ```
 要查看镜像的图层，还可以使用 docker inspect 命令：
 ```
 docker inspect your-image-name
 ```
 要删除镜像，请使用 docker image rm 命令：
 ```
 docker image rm your-image-name
 ```
 将映像推送到注册表
 构建映像后，可以将其推送到容器注册表（例如 Docker Hub、Google Container Registry 等），以便轻松分发和部署应用程序。首先，使用您的凭据登录注册表：
 ```
 docker login
 ```
 然后，使用注册表 URL 标记映像：
 ```
 docker tag your-image-name username/repository:tag
 ```
 最后，将标记的映像推送到注册表：
 ```
 docker push username/repository:tag
 ```
 构建容器映像是使用 Docker 的一个关键方面，因为它使你能够轻松打包和部署应用程序。通过创建具有精确指令的 Dockerfile，您可以毫不费力地在各种平台上构建和分发映像。
 Dockerfile
 Dockerfile 是一个文本文档，其中包含 Docker 引擎用于构建映像的指令列表。Dockerfile 中的每条指令都会向映像添加一个新层。Docker 将根据这些说明生成映像，然后您可以从映像运行容器。Dockerfile 是基础结构即代码的主要元素之一。
 ## **常见 Dockerfile 说明**
 以下是一些常见的 Dockerfile 指令及其用途的列表：
 ```
 FROM：    设置基础映像的开始。必须将 FROM 作为 Dockerfile 中的第一条指令。
 WORKDIR：   设置任何 RUN、CMD、ENTRYPOINT、COPY 或 ADD 指令的工作目录。如果该目录不存在，则会自动创建该目录。
 COPY：   将文件或目录从主机复制到容器的文件系统中。
 ADD：    类似于 COPY，但也可以处理远程 URL 并自动解压缩存档。
 RUN：    在镜像中作为新图层执行命令。
 CMD：    定义从映像运行容器时要执行的默认命令。
 ENTRYPOINT：    类似于 CMD，但它旨在允许容器作为具有自己参数的可执行文件。
 EXPOSE：    通知 Docker 容器将在运行时侦听指定的网络端口。
 ENV：    为容器设置环境变量。
 # 若要从 Dockerfile 生成映像，请使用 docker build 命令，指定生成上下文（通常为当前目录）和映像的可选标记。
 ```
 ```
 docker build -t my-image:tag .
 ```
 运行此命令后，Docker 将按顺序执行 Dockerfile 中的每条指令，并为每个指令创建一个新层。
 ## **高效的层缓存**
 构建容器镜像时，Docker 会缓存新创建的层。然后，这些图层可以在以后构建其他映像时使用，从而减少构建时间并最大限度地减少带宽使用。但是，要充分利用此缓存机制，您应该了解如何有效地使用图层缓存。
 Docker 层缓存的工作原理
 Docker 为 Dockerfile 中的每条指令（例如 RUN、COPY、ADD 等）创建一个新层。如果指令自上次生成以来未更改，则 Docker 将重用现有层。
 例如，请考虑以下 Dockerfile：
 ```
 FROM node:14
 WORKDIR /app
 COPY package.json /app/
 RUN npm install
 COPY . /app/
 CMD ["npm", "start"]
 ```
 首次构建镜像时，Docker 将执行每条指令并为每条指令创建一个新层。如果对应用程序进行一些更改并重新生成映像，Docker 将检查更改的指令是否影响任何层。如果任何层均不受更改的影响，则 Docker 将重用缓存的层。
 - 高效图层缓存的技巧
 - 尽量减少 Dockerfile 中的更改：尽量减少 Dockerfile 中更改的频率，并以最常更改的行显示在底部的方式构建指令。
 - 生成上下文优化：使用 .dockerignore 文件从生成上下文中排除可能导致缓存失效的不必要文件。
 - 使用较小的基础映像：较小的基础映像可减少提取基础映像所需的时间以及需要缓存的图层数.
 - 利用 Docker 的 --cache-from 标志：如果使用的是 CI/CD 管道，则可以指定要用作缓存源的镜像。
 - 合并多个指令：在某些情况下，合并指令（例如 RUN）有助于最大限度地减少层数，从而提高缓存效率。
 - 通过遵循这些最佳实践，您可以优化层缓存过程并减少 Docker 映像的构建时间，从而提高开发和部署过程的效率。
 ## **镜像大小和安全性**
 生成容器映像时，必须注意映像大小和安全性。映像的大小会影响容器的生成和部署速度。较小的映像可以加快构建速度，并降低下载映像时的网络开销。安全性至关重要，因为容器映像可能包含可能使应用程序面临风险的漏洞。
 Reducing Image Size 减小镜像尺寸
 使用适当的基础映像：选择更小、更轻量级的基础映像，该基础映像仅包含应用程序所需的组件。例如，请考虑使用官方镜像的 alpine 变体（如果可用），因为它的尺寸通常要小得多。
 FROM node:14-alpine
 在单个 RUN 语句中运行多个命令：每个 RUN 语句在镜像中创建一个新图层，该图层会影响镜像大小。使用 && 将多个命令合并为一个 RUN 语句，以最小化图层数并减小最终镜像大小。
 ```
 RUN apt-get update && \
    apt-get install -y some-required-package
 ```
 删除同一层中不必要的文件：在映像构建过程中安装包或添加文件时，请删除同一层中的临时或未使用的文件，以减小最终映像大小。
 ```
 RUN apt-get update && \
    apt-get install -y some-required-package && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*
 ```
 使用多阶段构建：使用多阶段构建创建较小的映像。多阶段构建允许您在 Dockerfile 中使用多个 FROM 语句。每个 FROM 语句在构建过程中创建一个新阶段。您可以使用 COPY --from 语句将文件从一个阶段复制到另一个阶段。
 ```
 FROM node:14-alpine AS build
 WORKDIR /app
 COPY package*.json ./
 RUN npm install
 COPY . .
 RUN npm run build
 FROM node:14-alpine
 WORKDIR /app
 COPY --from=build /app/dist ./dist
 COPY package*.json ./
 RUN npm install --production
 CMD ["npm", "start"]
 ```
 使用 .dockerignore 文件：使用 .dockerignore 文件从生成上下文中排除可能导致缓存失效并增加最终映像大小的不必要文件。
 ```
 node_modules
 npm-debug.log
 ```
 ## **Enhancing Security 增强安全性**
 保持基本映像更新：定期更新您在 Dockerfile 中使用的基本映像，以确保它们包含最新的安全补丁。
 - 避免以 root 身份运行容器：运行容器时始终使用非 root 用户，以最大程度地降低潜在风险。在运行应用程序之前创建用户并切换到该用户。
 ```
 RUN addgroup -g 1000 appuser && \
    adduser -u 1000 -G appuser -D appuser
 USER appuser
 ```
 - 限制 COPY 或 ADD 指令的范围：具体说明要复制到容器映像中的文件或目录。避免使用 COPY . .，因为它可能会无意中包含敏感文件。
 ```
 COPY package*.json ./
 COPY src/ src/
 ```
 - 扫描映像中的漏洞：使用 Anchore 或 Clair 等工具扫描映像中的漏洞，并在部署前修复它们。
--- a/content/learn-docker-7.md
+++ b/content/learn-docker-7.md
@ -1,220 +0,0 @@
 +++
 title = "Docker学习笔记(七)"
 date = 2024-03-31
 [taxonomies]
 tags = ["学习笔记"]
 +++
 前言 容器镜像仓库是 Docker 容器镜像的集中存储和分发系统。它允许开发人员以这些映像的形式轻松共享和部署应用程序。容器镜像仓库在容器化应用程序的部署中起着至关重要的作用，因为它们提供了一种快速、可靠且安全的方式来跨各种生产环境分发容器映像。
 <!-- more -->
 ## **Container Registries 容器镜像仓库**
 以下是当今可用的常用容器镜像仓库列表：
 - Docker Hub：Docker Hub 是公共 Docker 映像的默认注册表，用作在开发人员之间共享和分发映像的平台。
 - Google Container Registry （GCR）：GCR 是 Google Cloud Platform 提供的托管、安全且高度可用的注册表，非常适合托管私有容器镜像。
 - Amazon Elastic Container Registry （ECR）：Amazon ECR 是由 Amazon Web Services 提供的完全托管的 Docker 容器镜像仓库，为存储、管理和部署容器映像提供高可扩展性和性能。
 - Azure 容器镜像仓库 （ACR）：ACR 是 Microsoft Azure 提供的托管注册表，提供异地复制、访问控制以及与其他 Azure 服务的集成。
 **DockerHub**
 DockerHub 是 Docker Inc. 提供的基于云的注册服务。它是默认的公共容器镜像仓库，您可以在其中存储、管理和分发 Docker 映像。DockerHub 使其他用户可以轻松查找和使用您的映像，或者与 Docker 社区共享他们自己的映像。
 **DockerHub的功能**
 - 公共和私有存储库：将映像存储在每个人都可以访问的公共存储库中，或者选择仅限您的团队或组织访问的私有存储库。
 - 自动构建：DockerHub 与 GitHub 和 Bitbucket 等常用代码存储库集成，允许您为 Docker 映像设置自动构建。每当您将代码推送到存储库时，DockerHub 都会自动创建一个包含最新更改的新映像。
 - Webhook：DockerHub 允许您配置 Webhook，以便在构建或更新映像时通知其他应用程序或服务。
 - 组织和团队：通过创建组织和团队来管理对映像和存储库的访问，使协作变得容易。
 - 官方镜像：DockerHub 为 MongoDB、Node.js、Redis 等流行软件提供了一组精选的官方镜像。这些映像由 Docker Inc. 和上游软件供应商维护，确保它们是最新且安全的。
 要开始使用 DockerHub，您需要在他们的网站上创建一个免费帐户。注册后，您可以创建存储库、管理组织和团队以及浏览可用映像。
 当您准备好共享自己的映像时，可以使用 docker 命令行工具将本地映像推送到 DockerHub：
 ```
 docker login
 docker tag your-image your-username/your-repository:your-tag
 docker push your-username/your-repository:your-tag
 ```
 要从 DockerHub 拉取镜像，可以使用 docker pull 命令：
 ```
 docker pull your-username/your-repository:your-tag
 ```
 DockerHub 对于分发和共享 Docker 映像至关重要，使开发人员能够更轻松地部署应用程序和管理容器基础架构。
 ## **镜像标记最佳实践**
 正确标记 Docker 映像对于高效的容器管理和部署至关重要。在本节中，我们将讨论镜像标记的一些最佳实践。
 **使用语义版本控制**
 标记镜像时，建议遵循语义版本控制指南。语义版本控制是一种广受认可的方法，可以帮助更好地维护应用程序。Docker 镜像标签应具有以下结构 <major_version>.<minor_version>.<patch>。示例：3.2.1。
 **标记最新版本**
 除了版本号之外，Docker 还允许您将映像标记为“最新”。通常的做法是将映像的最新稳定版本标记为“最新”，以便用户无需指定版本号即可快速访问它。但是，在发布新版本时保持此标记更新非常重要。
 ```
 docker build -t your-username/app-name:latest .
 ```
 **具有描述性和一致性**
 选择清晰且描述性的标签名称，以传达镜像的用途或与先前版本相比的更改。您的标签还应该在映像和存储库中保持一致，以便更好地组织和易用。
 **包括生成和 Git 信息（可选）**
 在某些情况下，在镜像标记中包含有关构建和 Git 提交的信息可能会有所帮助。这有助于识别用于生成映像的源代码和环境。示例：app-name-1.2.3-b567-d1234efg。
 **使用特定于环境和体系结构的标签**
 如果应用程序部署在不同的环境（生产、暂存、开发）或具有多个体系结构（amd64、arm64），则可以使用指定这些变体的标记。示例：your-username/app-name:1.2.3-production-amd64。
 **需要时重新标记镜像**
 有时，您可能需要在将映像推送到注册表后重新标记映像。例如，如果您已经为应用程序发布了补丁，则可能需要使用与以前版本相同的标记重新标记新的补丁版本。这样可以更顺畅地更新应用程序，并减少需要应用补丁的用户的手动工作。
 **使用自动生成和标记工具**
 请考虑使用 CI/CD 工具（Jenkins、GitLab CI、Travis-CI）根据提交、分支或其他规则自动生成映像和标记。这确保了一致性，并减少了人工干预导致错误的可能性。
 通过遵循这些映像标记的最佳做法，可以确保 Docker 映像的容器注册表更有条理、更可维护且用户友好。
 ## **Running Containers 运行容器**
 要启动一个新容器，我们使用 docker run 命令，后跟映像名称。基本语法如下：
 ```
 docker run [options] IMAGE [COMMAND] [ARG...]
 ```
 例如，要运行官方的 Nginx 镜像，我们将使用：
 ```
 docker run -d -p 8080:80 nginx
 ```
 这将启动一个新容器，并将主机的端口 8080 映射到容器的端口 80。
 **Listing Containers 列出容器**
 要列出所有正在运行的容器，请使用 docker ps 命令。要查看所有容器（包括已停止的容器），请使用 -a 标志：
 ```
 docker container ls -a
 ```
 **Accessing Containers 访问容器**
 要访问正在运行的容器的 shell，请使用 docker exec 命令：
 ```
 docker exec -it CONTAINER_ID bash
 ```
 将 CONTAINER_ID 替换为所需容器的 ID 或名称。您可以在 docker ps 的输出中找到它。
 **Stopping Containers 停止容器**
 若要停止正在运行的容器，请使用 docker stop 命令，后跟容器 ID 或名称：
 ```
 docker container stop CONTAINER_ID
 ```
 **Removing Containers 移除容器**
 容器停止后，我们可以使用 docker rm 命令后跟容器 ID 或名称将其删除：
 ```
 docker container rm CONTAINER_ID
 ```
 若要在容器退出时自动删除容器，请在运行容器时添加 --rm 标志：
 ```
 docker run --rm IMAGE
 ```
 **使用 docker run 运行容器**
 在本节中，我们将讨论 docker run 命令，该命令使你能够运行 Docker 容器。docker run 命令从指定映像创建一个新容器并启动它。
 docker run 命令的基本语法如下：
 ```
 docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
 OPTIONS：这些是命令行标志，可用于调整容器的设置，如内存约束、端口、环境变量等。
 IMAGE：容器将运行的 Docker 映像。这可以是 Docker Hub 中的映像，也可以是存储在本地的您自己的映像。
 COMMAND：这是容器启动时将在容器内执行的命令。如果未指定，则将使用映像的默认入口点。
 ARG...：这些是可选参数，可以传递给正在执行的命令。
 ```
 **常用选项**
 以下是一些常用的 docker run 选项：
 ```
 --name：为容器分配名称，使其更易于识别和管理。
 -p, --publish：将容器的端口发布到主机。当您想要从容器外部访问容器内运行的服务时，这很有用。
 -e, --env：在容器内设置环境变量。您可以多次使用此选项来设置多个变量。
 -d, --detach：在分离模式下运行容器，在后台运行容器，并且不在控制台中显示日志。
 -v, --volume：将卷从主机绑定挂载到容器。这有助于持久保存容器生成的数据或在主机和容器之间共享文件。
 ```
 **下面是一些示例命令，可帮助您了解如何使用 docker run：**
 ```
 运行 Ubuntu 容器的交互式会话：
 docker run -it --name=my-ubuntu ubuntu
 运行 Nginx Web 服务器并在主机上发布端口 80：
 docker run -d --name=my-nginx -p 80:80 nginx
 使用自定义环境变量运行 MySQL 容器以配置数据库：
 docker run -d --name=my-mysql -e MYSQL_ROOT_PASSWORD=secret -e MYSQL_DATABASE=mydb -p 3306:3306 mysql
 使用绑定挂载卷运行容器：
 docker run -d --name=my-data -v /path/on/host:/path/in/container some-image
 ```
 ## **Docker Compose**
 Docker Compose 是用于定义和运行多容器 Docker 应用程序的工具。它允许您使用名为 docker-compose.yml 的简单 YAML 文件创建、管理和运行应用程序。此文件描述了应用程序的服务、网络和卷，使您只需使用一个命令即可轻松运行和管理容器。
 使用 Docker Compose 的一些好处包括：
 - 简化的容器管理：Docker Compose 允许您在一个地方定义和配置所有服务、网络和卷，使其易于管理和维护。
 - 可重现版本：与他人共享您的 docker-compose.yml 文件，以确保他们与您运行相同的环境和服务。
 - 版本控制支持：可以对 Docker Compose 文件进行版本控制，以便更轻松地兼容不同版本的 Docker Compose 工具本身。
 **创建 Docker Compose 文件：**
 若要创建 docker-compose.yml 文件，请首先指定要使用的 Docker Compose 版本，然后指定要定义的服务。下面是基本 docker-compose.yml 文件的示例：
 ```
 version: "3.9"
 services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
  db:
    image: mysql:latest
    environment:
      MYSQL_ROOT_PASSWORD: mysecretpassword
 ```
 在此示例中，我们指定了两个服务：运行最新版本的 nginx 映像的 Web 服务器 （web） 和运行 MySQL 的数据库服务器 （db）。Web 服务器将其端口 80 公开给主机，并且数据库服务器为 root 密码设置了环境变量。
 **运行 Docker Compose：**
 要运行 Docker Compose 应用程序，只需导航到包含 docker-compose.yml 文件的目录并运行以下命令：
 ```
 docker-compose up
 Docker Compose 将读取文件并按指定顺序启动定义的服务。
 ```
 **其他有用的命令：**
 ```
 docker-compose down：停止并删除 docker-compose.yml 文件中定义的所有正在运行的容器、网络和卷。
 docker-compose ps：列出 docker-compose.yml 文件中定义的所有容器的状态。
 docker-compose logs：显示 docker-compose.yml 文件中定义的所有容器的日志。
 docker-compose build：构建 docker-compose.yml 文件中定义的所有映像。
 ```
 ## **运行时配置选项**
 运行时配置选项允许您在运行 Docker 容器时自定义它们的行为和资源。这些选项有助于管理容器资源、安全性和网络。以下是一些常用运行时配置选项的简要摘要：
 **Resource Management 资源管理**
 CPU：您可以使用 --cpus 和 --cpu-shares 选项限制容器的 CPU 使用率。--cpus 限制容器可以使用的 CPU 内核数，而 --cpu-shares 为容器分配 CPU 时间的相对份额。
 ```
 docker run --cpus=2 --cpu-shares=512 your-image
 ```
 内存：您可以使用 --memory 和 --memory-reservation 选项限制和保留容器的内存。这有助于防止容器消耗过多的系统资源。
 ```
 docker run --memory=1G --memory-reservation=500M your-image
 ```
 **Security 安全**
 用户：默认情况下，容器以 root 用户身份运行。为了提高安全性，您可以使用 --user 选项以其他用户或 UID 身份运行容器。
 ```
 docker run --user 1000 your-image
 ```
 只读根文件系统：为防止对容器文件系统进行不必要的更改，可以使用 --read-only 选项将根文件系统挂载为只读。
 ```
 docker run --read-only your-image
 ```
 **Networking 联网**
 发布端口：可以使用 --publish（或 -p）选项将容器的端口发布到主机系统。这允许外部系统访问容器化服务。
 ```
 docker run -p 80:80 your-image
 ```
 主机名和 DNS：您可以使用 --hostname 和 --dns 选项自定义容器的主机名和 DNS 设置。
 ```
 docker run --hostname=my-container --dns=8.8.8.8 your-image
 ```
 包含这些运行时配置选项将使你能够有效地管理容器的资源、安全性和网络需求。有关可用运行时配置选项的完整列表，请参阅 Docker 的官方文档。
--- a/content/learn-docker-8.md
+++ b/content/learn-docker-8.md
@ -1,138 +0,0 @@
 +++
 title = "Docker学习笔记(八)"
 date = 2024-04-01
 [taxonomies]
 tags = ["学习笔记"]
 +++
 前言 容器安全是实现和管理容器技术（如 Docker）的关键方面。它包含一组实践、工具和技术，旨在保护容器化应用程序及其运行的基础结构。在本节中，我们将讨论一些关键的容器安全注意事项、最佳做法和建议。
 <!-- more -->
 ## **Container Security 容器安全**
 **Container Isolation 容器隔离**
 隔离对于确保容器化环境的稳健性和安全性至关重要。容器应彼此隔离并与主机系统隔离，以防止未经授权的访问，并在攻击者设法破坏一个容器时减轻潜在的损害。
 - 命名空间：Docker 使用命名空间技术为运行容器提供隔离环境。命名空间限制容器在更广泛的系统中可以查看和访问的内容，包括进程和网络资源。
 - C组：控制组 （cgroups） 用于限制容器消耗的资源，例如 CPU、内存和 I/O。 正确使用 cgroups 有助于防止 DoS 攻击和资源耗尽情况。
 **安全模式和做法**
 在容器的开发、部署和操作过程中实施最佳实践和特定安全模式对于维护安全环境至关重要。
 - 最小权限：应以尽可能低的权限运行容器，仅授予应用程序所需的最低权限。
 - 不可变的基础架构：容器应被视为不可变单元 - 一旦构建，就不应更改它们。任何更改都应通过从更新的映像部署新容器来实现。
 - 版本控制：映像应进行版本控制，并存储在安全的容器注册表中。
 **安全访问控制**
 应将访问控制应用于容器管理和容器数据，以保护敏感信息并维护整体安全态势。
 - 容器管理：使用基于角色的访问控制 （RBAC） 来限制对容器管理平台（例如 Kubernetes）的访问，并确保用户仅具有所需的最低权限。
 - 容器数据：对静态数据和传输中的数据进行加密，尤其是在处理敏感信息时。
 **容器漏洞管理**
 容器容易受到攻击，因为它们的映像依赖于各种包和库。为了降低这些风险，应将漏洞管理包含在容器生命周期中。
 - 镜像扫描：使用自动扫描工具识别容器和镜像中的漏洞。这些工具应集成到开发管道中，以便在潜在风险进入生产环境之前发现它们。
 - 安全基础映像：使用最小且安全的基础映像创建容器，从而减少攻击面和潜在漏洞。
 - 定期更新：使用最新的安全补丁和更新使基础映像和容器保持最新状态。
 ## **Image Security 镜像安全**
 映像安全是在环境中部署 Docker 容器的一个关键方面。确保您使用的镜像是安全的、最新的且没有漏洞至关重要。在本节中，我们将回顾用于保护和管理 Docker 映像的最佳实践和工具。
 **使用受信任的映像源**
 从公共存储库中提取映像时，请始终使用受信任的官方映像作为容器化应用程序的起点。官方映像由 Docker 审查，并定期更新安全修复程序。可以在 Docker Hub 或其他受信任的注册表上找到这些映像。
 Official Images: https://hub.docker.com/explore/
 从其他用户下载镜像或创建自己的镜像时，请务必验证源，并检查 Dockerfile 和其他提供的文件，以确保它们遵循最佳实践并且不会引入漏洞。
 **使镜像保持最新状态**
 持续监控您的镜像并定期更新它们。这有助于最大程度地减少已知漏洞的风险，因为更新通常包含安全补丁。
 您可以使用以下工具扫描和检查映像的更新：
 Docker Hub：https://hub.docker.com/
 Anchore: https://anchore.com/
 Clair: https://github.com/quay/clair
 **使用最少的基础映像**
 最小基础映像仅包含运行容器化应用程序所需的基本要素。基础映像中存在的组件越少，潜在漏洞的攻击面就越小。
 最小基础映像的一个示例是 Alpine Linux 发行版，由于其占用空间小和安全功能，它通常用于 Docker 映像。
 Alpine Linux: https://alpinelinux.org/
 Alpine Linux：https://alpinelinux.org/
 **扫描镜像以查找漏洞**
 使用 Clair 或 Anchore 等工具定期扫描镜像以查找已知漏洞。这些工具可以检测映像和容器配置中的潜在风险，从而允许您在将映像推送到注册表或在生产环境中部署映像之前解决这些风险。
 **对映像进行签名和验证**
 若要确保映像的完整性和真实性，请始终使用 Docker 内容信任 （DCT） 对映像进行签名。DCT 使用数字签名来保证您拉取或推送的镜像是您期望的镜像，并且在传输过程中未被篡改。
 Enable DCT for your Docker environment by setting the following environment variable:
 通过设置以下环境变量为 Docker 环境启用 DCT：
 ```
 export DOCKER_CONTENT_TRUST=1
 ```
 **利用多阶段构建**
 多阶段构建允许您在同一个 Dockerfile 中使用多个 FROM 指令。每个阶段可以具有不同的基础映像或指令集，但只有最终阶段才能确定最终映像的内容。通过使用多阶段构建，您可以最大程度地减少最终映像的大小和复杂性，从而降低漏洞风险。
 下面是一个使用多阶段构建的示例 Dockerfile：
 ```
 # Build stage
 FROM node:12-alpine AS build
 WORKDIR /app
 COPY . .
 RUN npm ci --production
 # Final stage
 FROM node:12-alpine
 COPY --from=build /app /app
 CMD ["npm", "start"]
 ```
 通过遵循这些映像安全最佳实践，您可以最大限度地降低漏洞风险，并确保容器化应用程序的安全。
 ## **Runtime Security 运行时安全性**
 运行时安全性侧重于确保 Docker 容器在生产环境中运行时的安全性。这是容器安全的一个关键方面，因为威胁可能会在部署容器后到达或被发现。适当的运行时安全措施有助于最大程度地减少漏洞被利用时可能造成的损害。
 **最小特权原则**
 确保您的容器遵循最小权限原则，这意味着它们应该只具有执行其预期功能所需的最低权限。这有助于限制容器受损时的潜在损坏。
 **尽可能以非 root 用户身份运行容器**
 避免运行特权容器，因为这些容器可以访问主机的所有资源。
 使用 Linux 功能从容器中剥离不必要的权限。
 **只读文件系统**
 通过将容器的文件系统设置为只读，可以防止攻击者修改关键文件或在容器中植入恶意软件。
 在启动容器时使用 --read-only 标志，使其文件系统为只读。
 为需要写入访问权限的位置实施卷装载或 tmpfs 装载。
 **安全扫描和监控**
 确保定期扫描容器中的漏洞，包括映像本身和运行时环境中的漏洞。
 **使用容器扫描工具检测和修补映像中的漏洞。**
 实施运行时监视以检测和响应安全事件，例如未经授权的访问尝试或意外的进程启动。
 **Resource Isolation 资源隔离**
 隔离容器的资源（如 CPU、内存和网络），以防止单个受感染的容器影响其他容器或主机系统。
 使用 Docker 的内置资源约束来限制容器可以使用的资源。
 使用网络分段和防火墙来隔离容器并限制其通信。
 **Audit Logs 审核日志**
 维护容器活动的审核日志，以帮助进行事件响应、故障排除和合规性。
 使用 Docker 的日志记录功能捕获容器日志，并将其输出到集中式日志记录解决方案。
 实施日志分析工具以监控可疑活动，并在检测到潜在事件时自动发出警报。
--- a/content/learn-docker-9.md
+++ b/content/learn-docker-9.md
@ -1,216 +0,0 @@
 +++
 title = "Docker学习笔记(九)"
 date = 2024-04-02
 [taxonomies]
 tags = ["学习笔记"]
 +++
 前言 Docker CLI（命令行界面）是一个强大的工具，允许您与 Docker 容器、映像、卷和网络进行交互和管理。它为用户提供了广泛的命令，用于在开发和生产工作流中创建、运行和管理 Docker 容器和其他 Docker 资源。
 <!-- more -->
 在本主题中，我们将深入探讨 Docker CLI 的一些关键方面，包括以下内容：
 **1. 安装**
 要开始使用 Docker CLI，您需要在计算机上安装 Docker。您可以按照 Docker 文档中相应操作系统的官方安装指南进行操作。
 **2. 基本命令**
 以下是一些需要熟悉的基本 Docker CLI 命令：
 ```
 docker run：从 Docker 镜像创建并启动容器
 docker container：列出正在运行的容器
 docker image：列出系统上所有可用的镜像
 docker pull：从 Docker Hub 或其他注册表拉取映像
 docker push：将映像推送到 Docker Hub 或其他注册表
 docker build：从 Dockerfile 构建映像
 docker exec：在正在运行的容器中运行命令
 docker logs：显示容器的日志
 ```
 **3. Docker 运行选项**
 docker run 是 Docker CLI 中最重要的命令之一。您可以使用各种选项自定义容器的行为，例如：
 ```
 -d, --detach：在后台运行容器
 -e, --env：为容器设置环境变量
 -v, --volume：绑定挂载卷
 -p, --publish：将容器的端口发布到主机
 --name：为容器分配名称
 --restart：指定容器的重启策略
 --rm：容器退出时自动移除容器
 ```
 **4. Dockerfile**
 Dockerfile 是一个脚本，其中包含用于构建 Docker 映像的指令。您可以使用 Docker CLI 通过 Dockerfile 构建、更新和管理 Docker 映像。
 下面是 Dockerfile 的简单示例：
 ```
 # Set the base image to use
 FROM alpine:3.7
 # Update the system and install packages
 RUN apk update && apk add curl
 # Set the working directory
 WORKDIR /app
 # Copy the application file
 COPY app.sh .
 # Set the entry point
 ENTRYPOINT ["./app.sh"]
 ```
 若要生成映像，请使用以下命令：
 ```
 docker build -t my-image .
 ```
 **5. Docker Compose**
 Docker Compose 是一个 CLI 工具，用于使用 YAML 文件定义和管理多容器 Docker 应用程序。它与 Docker CLI 协同工作，提供一种一致的方式来管理多个容器及其依赖项。
 使用官方安装指南安装 Docker Compose，然后您可以创建一个 docker-compose.yml 文件来定义和运行多容器应用程序：
 ```
 version: '3'
 services:
  web:
    image: webapp-image
    ports:
      - "80:80"
  database:
    image: mysql
    environment:
      - MYSQL_ROOT_PASSWORD=my-secret-pw
 ```
 使用以下命令运行应用程序：
 ```
 docker-compose up
 ```
 ## **Docker Images Docker 镜像**
 Docker 映像是轻量级、独立且可执行的包，其中包含运行应用程序所需的一切。这些映像包含所有必要的依赖项、库、运行时、系统工具和代码，使应用程序能够在不同的环境中一致地运行。
 Docker 映像是使用 Dockerfile 构建和管理的。Dockerfile 是一个脚本，其中包含用于创建 Docker 映像的指令，提供设置应用程序环境的分步指南。
 **使用 Docker 映像**
 Docker CLI 提供了多个命令来管理和处理 Docker 映像。一些基本命令包括：
 ```
 docker image ls: List all available images on your local system.
 docker image ls：列出本地系统上所有可用的镜像。
 docker build: Build an image from a Dockerfile.
 docker build：从 Dockerfile 构建映像。
 docker image rm: Remove one or more images.
 docker image rm：删除一个或多个镜像。
 docker pull: Pull an image from a registry (e.g., Docker Hub) to your local system.
 docker pull：将映像从注册表（例如 Docker Hub）拉取到本地系统。
 docker push: Push an image to a repository.
 docker push：将镜像推送到存储库。
 ```
 例如，要从 Docker Hub 拉取官方 Ubuntu 映像，可以运行以下命令：
 ```
 docker pull ubuntu:latest
 ```
 拉取映像后，可以使用该映像和 docker run 命令创建并运行容器：
 ```
 docker run -it ubuntu:latest /bin/bash
 ```
 此命令创建一个新容器，并使用 /bin/bash shell 在容器内启动交互式会话。
 **Sharing Images 共享镜像**
 可以使用容器注册表（如 Docker Hub、Google Container Registry 或 Amazon Elastic Container Registry （ECR））共享和分发 Docker 映像。将映像推送到注册表后，其他人可以轻松访问和使用它们。
 要共享您的镜像，您首先需要使用正确的命名格式对其进行标记：
 ```
 docker tag <image-id> <username>/<repository>:<tag>
 ```
 然后，您可以使用以下命令将标记的映像推送到注册表：
 ```
 docker push <username>/<repository>:<tag>
 ```
 **Containers 容器**
 容器可以被认为是轻量级、独立和可执行的软件包，其中包括运行软件所需的一切，包括代码、运行时、库、环境变量和配置文件。容器将软件与其周围环境隔离开来，确保它在不同的环境中统一工作。
 **为什么要使用容器？**
 - 可移植性：容器确保应用程序在不同平台上一致地工作，无论是开发人员的笔记本电脑还是生产服务器。这消除了“它在我的机器上工作”的问题。
 - 效率：容器是轻量级的，因为它们使用共享资源，而没有成熟操作系统的开销。这样可以缩短启动时间并减少资源使用。
 - 可扩展性：容器可以根据工作负载轻松扩展或缩减，使其成为分布式应用程序和微服务的理想选择。
 - 一致性：容器使开发人员、QA 和运营团队能够在整个应用程序生命周期中拥有一致的环境，从而实现更快、更顺畅的部署管道。
 - 安全性：容器提供与其他容器和底层主机系统的隔离级别，这有助于维护应用程序安全性。
 **使用 Docker CLI 处理容器**
 Docker CLI 提供了多个命令来帮助你创建、管理容器并与之交互。一些常用命令包括：
 ```
 docker run：用于创建和启动新容器。
 docker container ls：列出正在运行的容器。
 docker container stop：停止正在运行的容器。
 docker container rm：删除已停止的容器。
 docker exec：在正在运行的容器内执行命令。
 docker logs：获取容器的日志，可用于调试问题。
 ```
 ## **Docker Volumes** 
 Docker 卷是一种用于保存 Docker 容器生成和使用的数据的机制。它们允许您将数据与容器本身分开，从而轻松备份、迁移和管理持久性数据。
 **为什么卷很重要** 
 Docker 容器本质上是短暂的，这意味着它们可以很容易地停止、删除或替换。虽然这对于应用程序开发和部署非常有用，但在处理持久性数据时会带来挑战。这就是销量的来源。它们提供了一种独立于容器生命周期存储和管理数据的方法。
 **Types of Volumes 卷的类型**
 Docker 中有三种类型的卷：
 - 主机卷 Host Volumes：它们存储在主机的文件系统中，通常位于 /var/lib/docker/volumes 目录中。这些可以很容易地访问，但可能会带来可移植性或文件系统兼容性的问题。
 - 匿名卷 Anonymous Volumes：这些卷是在运行容器时自动创建的，无需指定卷。它们的 ID 由 Docker 生成，也存储在主机的文件系统中。
 - 命名卷 Named Volumes：与匿名卷类似，命名卷存储在主机的文件系统中。但是，您可以提供自定义名称，以便于在其他容器或备份中引用。
 **使用 Docker CLI 进行卷管理**
 Docker CLI 提供了各种命令来管理卷：
 ```
 docker volume create：创建具有给定名称的新卷。
 docker volume ls：列出系统上的所有卷。
 docker volume inspect：提供有关特定卷的详细信息。
 docker volume rm：删除卷。
 docker volume prune：删除所有未使用的卷。
 ```
 若要在容器中使用卷，可以在 docker run 命令中使用 -v 或 --volume 标志。例如：
 ```
 docker run -d --name my-container -v my-named-volume:/var/lib/data my-image
 ```
 此命令使用“my-image”映像创建名为“my-container”的新容器，并将“my-named-volume”卷挂载到容器内的 /var/lib/data 路径处。
 ## **Docker Networks Docker 网络**
 Docker 网络提供了管理容器通信的基本方法。它允许容器使用各种网络驱动程序相互通信以及与主机通信。通过了解和利用不同类型的网络驱动程序，可以设计容器网络以适应特定方案或应用程序要求。
 **Network Drivers 网络驱动程序**
 Docker 中提供了多个网络驱动程序。在这里，我们将介绍四种最常见的：
 - bridge：容器的默认网络驱动程序。它创建一个专用网络，容器可以在其中相互通信并与主机通信。此网络上的容器可以通过主机的网络访问外部资源。
 - host：此驱动程序删除网络隔离，并允许容器共享主机的网络。它适用于网络性能至关重要的情况，因为它可以最大程度地减少容器网络的开销。
 - none：此网络驱动程序禁用容器网络。使用此驱动程序的容器在隔离环境中运行，无需任何网络访问。
 - overlay：此网络驱动程序使部署在不同主机上的容器能够相互通信。它旨在与 Docker Swarm 配合使用，非常适合多主机或基于集群的容器部署。
 **管理 Docker 网络**
 Docker CLI 提供了各种命令来管理网络。以下是一些有用的命令：
 ```
 列出所有网络：docker network ls
 检查网络：docker network inspect <network_name>
 创建新网络：docker network create --driver <driver_type> <network_name>
 将容器连接到网络：docker network connect <network_name> <container_name>
 断开容器与网络的连接：docker network disconnect <network_name> <container_name>
 移除网络：docker network rm <network_name>
 ```