Docker笔记

Docker基础

Docker的主要组件和架构

Docker 是一个复杂的平台，其架构包括多个关键组件，它们协同工作以提供一个完整的容器化解决方案。这些组件包括 Docker Engine、Docker Hub、Docker Images 和 Docker Containers。下面详细介绍每个组件及其功能：

1. Docker Engine

Docker Engine 是 Docker 平台的核心，它是一个客户端-服务器类型的应用程序，包含以下主要部分：

• 守护进程（Daemon）：dockerd 守护进程是 Docker Engine 的服务端部分，负责创建、运行和监控 Docker 容器。守护进程处理来自 Docker 客户端的请求，并管理 Docker 的所有对象，如镜像、容器、网络和卷。
• REST API：Docker 提供了一个 RESTful API，允许开发者和第三方应用通过 HTTP/HTTPS 请求与 Docker 守护进程交互，实现远程管理容器。
• 命令行界面（CLI）：Docker 客户端通过命令行界面（CLI）与 Docker 守护进程通信。用户通过执行 docker 命令来启动、停止、管理容器以及执行其他相关任务。

2. Docker Hub

Docker Hub 是 Docker 的官方公共仓库，类似于 GitHub，但专门用于管理 Docker 镜像。它提供以下功能：

• 镜像托管和分发：用户可以将自己的镜像上传到 Docker Hub，使得这些镜像可以被公共访问或私有分享。Docker Hub 存储成千上万的 Docker 镜像，由社区和官方维护。
• 自动构建：Docker Hub 还支持与 GitHub 或 Bitbucket 仓库的集成，可以自动构建镜像并更新，每当源代码仓库发生变化时。
• 官方镜像：Docker Hub 提供多种官方镜像，这些镜像由 Docker 公司和其他官方机构维护，包括操作系统、数据库、应用程序服务器等。

3. Docker Images

Docker 镜像是一个轻量级、独立、可执行的软件包，包含运行某个软件所需的所有内容——代码、运行时、库、环境变量和配置文件。主要特点包括：

• 分层存储：每个 Docker 镜像由一系列的只读层组成。当创建一个新的镜像时，只添加一个新层。这种分层架构有助于共享资源，使镜像更易于管理和传输。
• 不变性：一旦创建，镜像中的内容将不会改变。这确保了环境的一致性和可复制性。

4. Docker Containers

Docker 容器是从 Docker 镜像创建的运行实例。容器是独立的、封装的环境，它们在用户空间运行，并使用宿主机的内核。容器的关键特性包括：

• 隔离性：虽然容器共享宿主机的操作系统，但每个容器运行在自己独立的环境中。容器具有自己的文件系统、网络配置和隔离的进程空间。
• 轻量级：容器不需要额外的操作系统负载，因此启动速度快，资源开销小。

这些组件共同构成了 Docker 的生态系统，使 Docker 成为开发、交付和运行应用程序的强大工具。

学习使用Docker命令行基本命令

Docker 的命令行界面（CLI）是与 Docker 交互的主要方式。以下是一些基本的 Docker 命令，它们用于管理 Docker 镜像和容器。

1. docker pull

此命令用于从远程仓库（如 Docker Hub）下载一个镜像或镜像的特定版本。如果不指定版本（标签），Docker 默认会拉取 latest 标签的镜像。

语法：

docker pull [OPTIONS] NAME[:TAG|@DIGEST]

示例：

docker pull ubuntu:18.04

这个命令会从 Docker Hub 下载 Ubuntu 18.04 的官方镜像。

2. docker run

docker run 命令用于创建一个新的容器并运行一个命令。这是最复杂的 Docker 命令之一，因为它具有许多可选参数，可以用来调整容器的行为。

语法：

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

示例：

docker run -it ubuntu:18.04 /bin/bash

这条命令启动了一个基于 ubuntu:18.04 镜像的容器，并打开一个交互式的终端（-it 使容器的 stdin 保持打开状态，并分配一个伪终端）。

3. docker ps

此命令列出当前运行的所有容器。加上 -a 参数，可以显示所有容器，包括未运行的。

语法：

docker ps [OPTIONS]

示例：

docker ps

只显示正在运行的容器。

bash

Copy code

docker ps -a

显示所有容器，包括未运行的。

4. docker stop

此命令用于停止一个或多个正在运行的容器。

语法：

docker stop [OPTIONS] CONTAINER [CONTAINER...]

示例：

docker stop my_container

停止名为 my_container 的容器。

其他基本命令

• docker start CONTAINER: 启动一个或多个已经停止的容器。
• docker restart CONTAINER: 重启一个或多个容器。
• docker rm CONTAINER: 删除一个或多个容器。
• docker rmi IMAGE: 删除一个或多个镜像。

通过这些基本命令，您可以开始在 Docker 中创建、运行、监控和管理容器。对于初学者来说，熟练掌握这些命令是非常重要的，因为它们构成了使用 Docker 的基础。随着经验的积累，您可以进一步探索更高级的功能和命令。

实践

Docker容器操作

Docker镜像与容器的生命周期管理

Docker 镜像和容器的生命周期管理是 Docker 使用中的核心概念。理解这些概念对于有效地使用 Docker 是非常重要的。以下是 Docker 镜像和容器的生命周期管理的详细介绍。

Docker 镜像的生命周期管理

1. 创建镜像

Docker 镜像可以通过以下几种方式创建：

• 从现有镜像运行一个容器并在其中进行更改：在容器中安装新软件或修改配置文件，然后使用 docker commit 命令从修改后的容器创建新镜像。
• 使用 Dockerfile：Dockerfile 是一个包含了一系列指令和参数的文本文件，这些指令和参数定义了如何构建镜像。使用 docker build 命令根据 Dockerfile 来构建新镜像。

2. 存储和共享镜像

• 本地存储：创建或下载的镜像存储在本地 Docker 主机上。
• 远程仓库：可以将镜像推送到远程仓库（如 Docker Hub 或私有仓库）以供团队或公众使用。使用 docker push 命令上传镜像。

3. 更新镜像

更新镜像通常涉及修改 Dockerfile 或更新容器状态后再次使用 docker commit 命令。更新完成后，可以重新构建并推送到仓库。

4. 删除镜像

使用 docker rmi 命令删除不再需要的镜像。如果有容器正在使用某个镜像，那么该镜像不能被删除，除非使用强制删除选项。

Docker 容器的生命周期管理

1. 创建容器

使用 docker run 命令从镜像创建新容器。此命令允许指定多种参数来控制容器的行为。

2. 运行和管理容器

• 启动、停止、重启：使用 docker start, docker stop, docker restart 等命令来控制容器的运行状态。
• 查看容器信息：使用 docker ps 查看运行中的容器，使用 docker logs 查看容器的日志输出。

3. 进入运行中的容器

使用 docker exec 命令在运行的容器内启动一个新的交互式进程，例如，启动一个 Bash 会话。

4. 更新容器

容器的更新通常通过替换底层的镜像来完成。这需要停止当前容器，从更新过的镜像重新创建一个新容器。

5. 删除容器

使用 docker rm 命令删除已停止的容器。运行中的容器必须先停止，或者使用 docker rm -f 强制删除。

数据持久化

为了管理数据的生命周期，Docker 提供了卷（Volumes）和绑定挂载（Bind Mounts）两种方式来持久化和管理数据。

• 卷：由 Docker 管理，可以在容器之间共享和重用。
• 绑定挂载：直接映射宿主机的文件或目录到容器中。

理解和掌握这些 Docker 镜像和容器的生命周期管理技能是高效使用 Docker 的关键。这不仅涉及到容器的运行和维护，还包括如何通过持久化和版本控制来管理数据和应用配置。

Docker文件和镜像构建（Dockerfile的基本指令）

Dockerfile 是一个文本文件，包含了一系列的指令和参数，这些指令用于自动构建 Docker 镜像。每一个指令都会在镜像中创建一个新的层。下面是一些基本的 Dockerfile 指令及其用途：

1. FROM

此指令定义了新镜像的基础镜像。每个 Dockerfile 必须从一个 FROM 指令开始（除非前面使用了 ARG 指令），因为它指定了构建过程的起点。

示例：

FROM ubuntu:18.04

2. RUN

RUN 指令用来在镜像中执行命令，添加新层。RUN 常用于安装软件包。

示例：

RUN apt-get update && apt-get install -y python3

3. CMD

CMD 指令提供了容器的默认执行命令。Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效。

示例：

CMD ["echo", "Hello world"]

4. LABEL

LABEL 指令用于为镜像添加元数据。如作者、版本、描述等。

示例：

LABEL maintainer="name@example.com"

5. EXPOSE

EXPOSE 指令用于指定容器在运行时监听的端口。

示例：

EXPOSE 80

6. ENV

ENV 指令用于设置环境变量，这些变量可以在运行时被容器内的应用访问。

示例：

ENV MY_VAR my_value

7. ADD 和 COPY

• ADD 指令复制文件、目录或远程文件URL到镜像，并可自动解压压缩文件。
• COPY 是更基本的版本，专门用于复制本地文件和目录到镜像中，不具备网络下载和自动解压功能。

示例：

ADD https://example.com/big.tar.xz /usr/src/things/ COPY ./localdir /usr/share/localdir

8. ENTRYPOINT

ENTRYPOINT 指令用于设置容器启动时运行的命令，与 CMD 配合使用，可以让容器以应用程序或服务的形式运行。

示例：

ENTRYPOINT ["entrypoint.sh"]

当结合 CMD 使用时，CMD 指定的参数会被传递给 ENTRYPOINT。

9. VOLUME

VOLUME 指令用于在镜像中创建一个挂载点标记，主要用于挂载外部卷或其他容器的卷。

示例：

VOLUME /data

10. WORKDIR

WORKDIR 指令用于设置工作目录（即当前目录），所有的 RUN, CMD, ENTRYPOINT, COPY 和 ADD 指令都会在设置的工作目录下执行。

示例：

WORKDIR /path/to/workdir

通过这些指令的组合使用，可以灵活地定义如何构建 Docker 镜像以满足不同的应用需求。每个 RUN、COPY 和 ADD 指令都会添加一个新的层到镜像，因此合理组织这些指令的顺序和结构，可以帮助减少最终镜像的大小并提高构建效率。

管理和查看容器日志

在 Docker 中，管理和查看容器的日志是一个重要的操作，它可以帮助你监控容器的运行状况和调试应用程序。Docker 提供了几种方法来处理容器日志。

查看容器日志

最基本的命令是 docker logs，它用于查看容器的输出，即容器的标准输出（STDOUT）和标准错误（STDERR）。

语法：

docker logs [OPTIONS] CONTAINER

选项：

• --follow 或 -f：跟踪日志输出。这会持续返回日志数据，直到你中断它（比如按 Ctrl+C）。
• --tail：显示日志的最后N行。例如，--tail 100 显示最后100行日志。
• --since：显示自某个时间以来的日志，例如 --since 2023-01-01T00:00:00 或 --since 1h（过去一小时的日志）。
• --timestamps 或 -t：在每行日志前显示时间戳。
• --until：显示直到某个时间的日志。

示例：

docker logs my_container
docker logs -f my_container
docker logs --tail 50 my_container
docker logs --since 10m my_container

配置日志

在 Docker 中，可以通过修改容器的日志配置来控制日志的处理方式。这通常在运行容器时通过 --log-driver 选项来设置。Docker 支持多种日志驱动程序，如 json-file（默认）、syslog、journald、gelf、fluentd、awslogs 等。

• json-file：将日志以 JSON 格式存储在本地文件中。
• syslog：将日志发送到 syslog 守护进程。
• journald：将日志发送到 systemd 的 journal 中。
• gelf：使用 Graylog Extended Log Format（GELF）将日志发送到 Graylog 服务器。

示例：使用 syslog 日志驱动程序

docker run --log-driver=syslog --name my_container my_image

清理日志

对于使用默认的 json-file 日志驱动程序的容器，日志文件可能会随着时间而变大，需要定期清理。清理日志并不是通过 Docker 直接完成的，而是需要在宿主机上手动处理或者编写脚本定期删除旧日志文件。例如，你可以定位到 /var/lib/docker/containers/ 目录，找到相应容器的日志文件，并清理它们。

总结一下，管理和查看容器日志在 Docker 运维中非常关键，它帮助管理员和开发者获取容器的运行状态和问题诊断信息。了解如何有效使用 docker logs 命令以及配置不同的日志驱动对于优化容器管理和监控是非常有帮助的。

实践：从Docker Hub拉取镜像

从 Docker Hub 拉取镜像是 Docker 的基本操作之一，它允许用户从 Docker Hub 或其他注册中心下载公共或私有镜像到本地环境。Docker Hub 是 Docker 的官方公共仓库，其中包含了数以万计的镜像，由社区或官方维护。

拉取镜像的步骤

1. 打开终端

首先，确保你的机器上已安装 Docker 并且 Docker 服务正在运行。可以通过运行 docker --version 来检查 Docker 是否已正确安装。

2. 使用 docker pull 命令

使用 docker pull 命令从 Docker Hub 拉取镜像。该命令的基本语法是：

docker pull [OPTIONS] NAME[:TAG|@DIGEST]

• NAME 是镜像的名称。
• TAG 是可选的，指定镜像的特定版本，默认为 latest。
• @DIGEST 是可选的，用于指定镜像的特定摘要，主要用于确保下载的是完全相同的镜像。

3. 示例：拉取 Ubuntu 镜像

如果你想拉取 Ubuntu 操作系统的最新镜像，可以使用以下命令：

docker pull ubuntu

这将从 Docker Hub 下载带有 latest 标签的 Ubuntu 镜像。

如果你想下载特定版本的 Ubuntu 镜像，如 Ubuntu 20.04，则需要指定相应的标签：

docker pull ubuntu:20.04

4. 验证镜像是否已下载

下载完成后，可以使用 docker images 命令列出本地所有可用的 Docker 镜像，以验证是否已成功拉取：

docker images 

此命令将显示本地所有镜像的列表，包括 REPOSITORY、TAG、IMAGE ID、CREATED 和 SIZE 等信息。

常见问题

• 网络问题：确保你的网络连接稳定，否则镜像下载可能会中断。
• 存储空间：拉取大型镜像前确保本地有足够的存储空间。
• 权限问题：某些操作（尤其是在 Linux 上）可能需要管理员权限，使用 sudo 前缀运行 Docker 命令。

拉取镜像是开始使用 Docker 容器的第一步，一旦本地拥有了需要的镜像，就可以基于这些镜像创建和运行容器。

实践：构建自定义Docker镜像

构建自定义 Docker 镜像通常是通过编写一个叫做 Dockerfile 的配置文件来完成的。Dockerfile 定义了从基础镜像开始，如何一步步构建新镜像所需的所有命令和步骤。以下是创建和构建自定义 Docker 镜像的基本步骤：

第 1 步：创建一个 Dockerfile

首先，你需要创建一个名为 Dockerfile 的文本文件（没有文件扩展名），并在其中定义构建镜像所需的步骤。

示例 Dockerfile：

# 使用官方 Python 运行时作为父镜像
FROM python:3.8-slim

# 设置工作目录为 /app
WORKDIR /app

# 将当前目录内容复制到位于 /app 的容器中
COPY . /app

# 安装 requirements.txt 中指定的任何所需包
RUN pip install --trusted-host pypi.python.org -r requirements.txt

# 使端口 80 可用于此容器外的通信
EXPOSE 80

# 定义环境变量
ENV NAME World

# 在容器启动时运行 app.py
CMD ["python", "app.py"]

这个 Dockerfile 指定了从一个 Python 镜像开始，添加当前目录的内容到镜像中，安装所需的 Python 包，暴露端口 80，设置一个环境变量，并指定了容器启动时应运行的命令。

第 2 步：构建镜像

在 Dockerfile 文件所在目录中打开终端，运行以下命令来构建镜像。-t 标签给镜像设定了一个名称和（可选的）标签，通常用于管理版本。

docker build -t my-python-app .

这里 my-python-app 是你为镜像设定的名称，点号 . 指的是 Docker 应该在当前目录查找 Dockerfile。

第 3 步：检查镜像

构建完成后，可以使用 docker images 命令查看本地可用的镜像列表：

docker images 

第 4 步：运行你的新镜像

构建出新镜像后，可以通过以下命令运行一个基于该镜像的容器：

docker run -p 4000:80 my-python-app 

这里 -p 4000:80 表示将容器的 80 端口映射到主机的 4000 端口上，这样你就可以通过访问主机的 4000 端口来访问应用。

常见问题

• 构建上下文过大：如果你的目录中有很多文件，Docker 构建可能会变慢，因为 Docker 客户端会将所有文件发送到守护进程。可以创建 .dockerignore 文件，类似 .gitignore，来排除不需要的文件和目录。
• 构建错误：如果 Dockerfile 中的指令错误或者不一致，例如 COPY 或 RUN 命令失败，构建过程将会停止并报错。检查错误消息通常可以找到问题所在。

通过这些步骤，你可以构建自定义的 Docker 镜像，该镜像可以用于开发、测试或生产环境。

管理（启动、停止、删除）容器

管理 Docker 容器涉及多种操作，包括启动、停止、删除容器等。了解如何执行这些基本操作是有效使用 Docker 的关键。

启动容器

启动容器的最常用命令是 docker run，它从指定的镜像创建一个新的容器并启动它。如果镜像不存在于本地，Docker 会尝试从远程仓库（如 Docker Hub）下载它。

docker run -d -p 8080:80 --name webserver nginx

• -d 参数表示在后台运行容器。
• -p 8080:80 表示将容器的 80 端口映射到主机的 8080 端口。
• --name webserver 为容器设置一个名字，方便后续管理。
• nginx 是从 Docker Hub 拉取的镜像名称。

如果容器已经创建，你可以使用 docker start 命令通过容器的 ID 或名称来启动它：

docker start webserver

停止容器

当你需要停止运行中的容器时，可以使用 docker stop 命令。这个命令会向容器发送 SIGTERM 信号，请求容器优雅地停止。如果容器在一定时间内未能正常停止（默认为 10 秒），则会发送 SIGKILL 信号强制停止容器。

docker stop webserver

重启容器

如果需要重启一个容器，可以使用 docker restart 命令。这对于应用更新或环境变量更改后重新加载配置非常有用。

docker restart webserver

查看容器状态

要查看当前运行的容器，使用 docker ps 命令。如果想查看所有容器（包括停止的容器），可以添加 -a 选项：

docker ps docker ps -a

删除容器

当容器不再需要时，可以使用 docker rm 命令来删除它。删除容器前需要确保容器已停止运行，否则需要加 -f 参数强制删除。

docker rm webserver

如果要删除正在运行的容器，可以结合使用停止和删除命令：

docker stop webserver docker rm webserver

或者使用强制删除的方式：

docker rm -f webserver

清理命令

Docker 还提供了一些命令来帮助清理不再使用的资源，例如：

• docker system prune：删除所有未使用的容器、网络、挂载的卷与悬空镜像。
• docker container prune：删除所有停止的容器。

这些管理命令为 Docker 容器的日常运维提供了全面的支持，使得用户可以轻松地控制和维护容器的生命周期。

使用Docker logs监控容器活动

docker logs 命令是一个非常有用的工具，它允许你访问 Docker 容器的日志，即容器的标准输出（STDOUT）和标准错误输出（STDERR）。这使得监控和调试运行在 Docker 容器内的应用变得简单。理解如何使用 docker logs 命令可以帮助你更好地管理容器应用的运行状态和问题排查。

基本用法

要查看容器的日志，你需要知道容器的名称或 ID。使用以下命令可以查看指定容器的日志：

docker logs [CONTAINER]

其中 [CONTAINER] 是容器的名称或 ID。

实用选项

• -f 或 --follow：此选项允许你实时跟踪日志输出。这就像是在传统系统中用 tail -f 查看日志文件。

  docker logs -f [CONTAINER]

• --since：此选项让你指定一个时间点，只显示那个时间点之后的日志。你可以使用相对时间（如 5m、3h）或确切的时间戳（如 2023-01-01T13:23:37）。

  docker logs --since 5m [CONTAINER]

• --until：与 --since 相对应，此选项允许你指定一个结束时间，从而查看在这个时间点之前的日志。

  docker logs --until 2023-01-01T13:23:37 [CONTAINER]

• --tail：此选项用于显示日志的最后N行。非常适合当日志文件非常大时，只查看最新的日志条目。

  docker logs --tail 100 [CONTAINER]

• -t 或 --timestamps：此选项将在每条日志前添加一个时间戳，帮助你了解每条日志记录的具体时间。

  docker logs -t [CONTAINER]

用例

假设你正在运行一个 Web 服务器容器，容器名称为 webserver，你可能需要监控其活动来确保服务正常运行：

docker logs -f webserver

如果你想看看昨天此容器的活动情况，你可以使用：

docker logs --since 24h webserver

这将显示从现在起24小时前的日志。

注意事项

• docker logs 只适用于那些直接写入到 STDOUT 和 STDERR 的容器。如果应用程序将日志写入到内部文件中，你将需要通过其他方式（如 Docker 卷）来访问这些文件。
• 在生产环境中，建议使用更持久和更可扩展的日志解决方案，如将日志发送到外部日志记录服务（例如 ELK 栈、Fluentd 或 Datadog）。

通过 docker logs，你可以有效地监控和调试容器，这对于维护和优化容器化应用至关重要。

Docker网络和数据管理

Docker网络模型和端口映射

Docker 的网络模型提供了强大的工具和抽象，使容器能够与外部世界和其他容器进行通信。Docker 提供了多种网络驱动，允许你根据需要创建不同类型的网络。同时，端口映射功能使得容器内运行的服务可以从容器外部访问。

Docker 网络驱动

Docker 支持以下几种主要的网络驱动：

1. bridge：默认网络驱动。当你运行一个容器时，如果没有指定网络，它就会自动连接到一个私有内部网络，并通过桥接方式连接到主机。这允许容器与外部通信。

2. host：如果使用 host 网络，容器将不会获得自己的 IP 地址，它会直接使用宿主机的网络。这意味着容器的网络栈不会与宿主机隔离。

3. overlay：用于 Docker Swarm 集群，支持不同 Docker 守护进程的容器间的网络通信，实现跨主机的容器网络。

4. macvlan：允许你为每个容器分配一个 MAC 地址，好像它们是物理设备一样，这使得容器能够直接连接到物理网络。

5. none：禁用所有网络。通常用于高级网络配置，或当你想自己处理容器的网络时使用。

端口映射

端口映射是将容器内的端口映射到主机上的端口，使得从外部网络能够访问运行在容器内部的服务。这是通过 Docker 命令行的 -p 或 --publish 选项来配置的。

语法

docker run -p <host_port>:<container_port> [其他选项] <image>

• <host_port>：宿主机上的端口。
• <container_port>：容器内的端口。

示例

如果你想运行一个 web 服务器容器，并将其 80 端口映射到宿主机的 8080 端口，可以使用以下命令：

docker run -p 8080:80 nginx

这个命令将启动一个 nginx 容器，宿主机的 8080 端口将被映射到容器的 80 端口。这样，你就可以通过访问宿主机的 8080 端口来访问 nginx 服务。

网络模型的其他特点

• DNS 解析：Docker 自带的 DNS 服务器允许通过容器名称进行 DNS 解析，这对于在同一网络内的容器间通信非常有用。
• 容器间连接：可以在同一个网络中的容器之间建立连接，使得它们可以相互通信，而无需端口映射到宿主机。
• 隔离：不同的网络提供了网络级别的隔离，不同网络中的容器默认是无法相互通信的。

Docker 的网络功能非常强大，可以满足各种应用场景的需要。通过恰当地配置网络和端口映射，你可以轻松地管理容器间的通信和容器与外界的连接。

Docker数据卷和卷容器的使用

Docker 数据卷是 Docker 容器中用于数据持久化和数据共享的一种机制。它们设计用来持久保存数据，即使容器被删除，数据也不会丢失。数据卷可以被挂载到容器的指定目录中，允许数据在容器之间或从主机到容器之间轻松共享。

数据卷的主要特点

1. 持久化和独立于容器的生命周期：数据卷的生命周期独立于容器，容器删除后，数据卷不会自动删除，可以被其他容器重新挂载和使用。
2. 容器间共享：数据卷可以被多个容器同时挂载，实现数据共享。
3. 效率：数据卷提供了比复制文件更高效的数据访问方式。

创建和管理数据卷

创建新卷

使用 docker volume create 命令创建一个新的数据卷：

docker volume create my-vol

查看所有数据卷

列出所有的数据卷：

docker volume ls

删除数据卷

移除不再需要的数据卷：

docker volume rm my-vol

使用数据卷

在 docker run 命令中挂载数据卷

当运行容器时，可以通过 -v 或 --mount 标志挂载数据卷到容器中。例如，将上面创建的 my-vol 挂载到容器的 /app 目录：

docker run -d -v my-vol:/app nginx

这个命令启动了一个 nginx 容器，并将 my-vol 数据卷挂载到容器内的 /app 目录。

使用 --mount 语法

--mount 是更现代的挂载选项，它更为详细和显式：

docker run -d --mount type=volume,source=my-vol,target=/app nginx

卷容器的使用（容器间数据共享）

卷容器是一个普通的容器，专门用于在其他容器之间共享数据。创建一个卷容器，然后将它的卷挂载到其他需要访问该数据的容器上。

创建卷容器

docker run -d --name vol-container -v my-vol:/app nginx

使用卷容器的卷

你可以使用 --volumes-from 选项将 vol-container 中的卷挂载到另一个容器：

docker run -d --name app-container --volumes-from vol-container nginx

这个命令将启动一个新的 nginx 容器，并从 vol-container 继承 my-vol 数据卷的挂载，使得两个容器可以共享 /app 目录中的数据。

数据卷的优点

• 数据安全性：数据卷不会被容器直接更改，它们是独立管理和备份的。
• 灵活性：数据卷可以在容器之间自由移动，使得数据管理更灵活。
• 效率：使用数据卷可以避免复制和保存临时数据的开销。

数据卷是 Docker 中处理数据持久性和共享的首选方式，特别是在生产环境中，使用数据卷可以提供更高的性能和可靠性。

Docker Compose的基本用法和场景

Docker Compose 是一个用于定义和运行多容器 Docker 应用程序的工具。通过一个 YAML 文件（通常命名为 docker-compose.yml），你可以配置你的应用的服务、网络和卷等资源。这使得启动、停止和重建服务变得非常简便，尤其是在开发和测试环境中。

基本用法

1. 编写 Docker Compose 文件

首先，你需要创建一个 docker-compose.yml 文件，它定义了所需要的服务及其配置。

示例 docker-compose.yml：

version: '3.8'
services:
  web:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/share/nginx/html
  database:
    image: postgres
    environment:
      POSTGRES_PASSWORD: example

在这个示例中，定义了两个服务：

• web：使用 nginx 镜像，并将主机上的一个目录挂载到容器内，同时将容器的 80 端口映射到主机的 80 端口。
• database：使用 postgres 镜像，并设置环境变量 POSTGRES_PASSWORD。

2. 启动服务

在包含 docker-compose.yml 文件的目录中运行以下命令来启动所有服务：

docker-compose up

如果你希望在后台运行这些服务，可以添加 -d 参数：

docker-compose up -d

3. 查看服务状态

要查看当前运行的服务状态，可以使用：

docker-compose ps 

4. 停止服务

要停止并移除所有由 docker-compose up 命令启动的容器，可以使用：

docker-compose down

场景和用途

开发环境

在开发环境中，Docker Compose 用于快速启动和配置涉及多个容器的应用，例如，一个 Web 应用程序可能包括一个 Web 服务器、一个数据库和一个缓存服务。

自动化测试

Docker Compose 允许开发者定义和启动一个完整的应用环境，运行自动化测试，然后拆解，这使得持续集成/持续部署 (CI/CD) 流程中的测试变得简单可重复。

生产部署

虽然 Docker Compose 主要用于开发和测试环境，但它也可以用于生产。它使得服务配置、网络和卷的管理更加标准化和简化。然而，对于更大规模的生产环境，通常推荐使用如 Kubernetes 或 Docker Swarm 这样的更强大的容器编排工具。

扩展和管理

Docker Compose 还支持扩展服务、查看服务日志、运行服务级别的命令等高级功能。例如，你可以使用 docker-compose logs 查看服务的输出，或者使用 docker-compose exec 在运行的服务中执行命令。

Docker Compose 是 Docker 生态系统中的重要工具之一，通过简化多容器应用的配置和管理，它显著提高了开发和部署的效率。

实践创建和管理Docker网络

在 Linux 下使用 Docker 管理网络涉及创建自定义网络、查看网络详情、连接或断开容器与网络的连接，以及删除网络。Docker 提供了多种网络类型，例如 bridge、host、overlay 和 macvlan，每种都适用于不同的场景。

创建 Docker 网络

1. 创建一个新的网络 使用 docker network create 命令来创建一个新的网络。可以指定网络的类型（默认为 bridge）。例如，创建一个名为 my-network 的 bridge 网络：

   docker network create --driver bridge my-network

   如果需要创建 overlay 网络，通常用于跨多个 Docker 守护进程的容器通信（例如，在 Docker Swarm 模式下），可以指定 overlay 驱动：

   docker network create -d overlay my-overlay
   

查看网络信息

1. 列出所有网络 使用 docker network ls 命令列出系统中所有的 Docker 网络：

   docker network ls

2. 查看网络详细信息 使用 docker network inspect 命令查看特定网络的详细信息，包括哪些容器连接到了这个网络：

   docker network inspect my-network

管理网络连接

1. 连接容器到网络 使用 docker network connect 命令将已经存在的容器连接到网络。这对于将容器动态添加到网络非常有用。例如，将一个名为 my-container 的容器连接到 my-network 网络：

   docker network connect my-network my-container

2. 从网络断开容器 使用 docker network disconnect 命令将容器从网络中断开。这不会停止容器，只是中断其网络连接。例如，从 my-network 网络中断开 my-container：

   docker network disconnect my-network my-container

删除网络

1. 删除网络 使用 docker network rm 命令删除不再需要的网络。在删除网络之前，确保没有任何容器仍然连接到该网络：

   docker network rm my-network

   如果尝试删除仍有容器连接的网络，操作将失败，必须先断开所有容器的连接。

实际应用

在实际应用中，合理地管理 Docker 网络可以帮助你构建更加安全和高效的应用架构。例如，通过创建隔离的网络，你可以控制容器间的通信，增强安全性；使用 overlay 网络可以方便地在多个主机间管理容器网络，适合于大规模部署。

这些基本的 Docker 网络操作能够让你在日常工作中更有效地使用 Docker 管理多容器环境。

实践：使用数据卷进行数据持久化

在 Docker 中，使用数据卷（Volumes）进行数据持久化是一种管理和存储数据的有效方式。数据卷独立于容器的生命周期存在，这意味着你可以在容器被删除后仍然保留和访问数据。此外，数据卷可以在多个容器之间共享和重用。

创建和管理数据卷

创建数据卷

你可以使用 docker volume create 命令来创建一个新的数据卷。例如，创建一个名为 my-vol 的数据卷：

docker volume create my-vol

列出数据卷

查看系统中所有的数据卷：

docker volume ls

查看数据卷详情

查看特定数据卷的详细信息：

docker volume inspect my-vol

使用数据卷

在容器中使用数据卷

当你运行一个容器时，可以通过 -v 或 --mount 标志将数据卷挂载到容器中。--mount 是推荐的方式，因为它的语法更明确，更易于理解。

使用 -v 挂载数据卷：

docker run -d -v my-vol:/app nginx

这个命令将 my-vol 挂载到基于 nginx 镜像创建的容器的 /app 目录。

使用 --mount 挂载数据卷：

docker run -d --mount type=volume,source=my-vol,target=/app nginx

这里 type=volume 指明挂载类型为数据卷，source=my-vol 指明数据卷的名称，target=/app 是容器内的挂载点。

数据卷的共享和重用

数据卷可以被多个容器同时挂载，这允许不同容器访问和共享相同的数据。例如，你可以同时让两个容器挂载同一个数据卷：

docker run -d --name container1 --mount type=volume,source=my-vol,target=/app nginx
docker run -d --name container2 --mount type=volume,source=my-vol,target=/app nginx

这两个容器都将 my-vol 挂载在各自的 /app 目录下，它们可以读写同一个数据卷中的数据。

删除数据卷

当数据卷不再需要时，可以使用 docker volume rm 命令来删除它：

docker volume rm my-vol

注意事项

• 确保在删除数据卷之前，没有容器正在使用它。
• 数据卷的使用不限于本地驱动；Docker 还支持第三方卷驱动插件，如 NFS 或 cloud-based storage，这为数据持久化提供了更多的灵活性和选项。

使用数据卷进行数据持久化是 Docker 最佳实践之一，特别是在生产环境中，它不仅保证了数据的安全，也提供了高效的数据访问方式。

实践：使用Docker Compose编排多容器应用

Docker Compose 是一个非常实用的工具，用于定义和运行多容器 Docker 应用。它允许您使用一个 YAML 文件来配置您的应用的服务、网络、卷等。这使得整个部署过程可以自动化，容易管理，并且可以通过单一的命令启动和停止整个应用。

创建 docker-compose.yml 文件

创建一个 Docker Compose 文件通常是开始编排多容器应用的第一步。这个文件定义了所有的服务（每个服务通常运行一个容器）、网络和卷。

示例 docker-compose.yml 文件：

version: '3.8'  # 使用的 Docker Compose 文件版本
services:
  web:
    image: nginx  # 使用 nginx 官方镜像
    ports:
      - "80:80"  # 将宿主机的 80 端口映射到容器的 80 端口
    volumes:
      - ./html:/usr/share/nginx/html  # 将宿主机的 ./html 目录挂载到容器内
    depends_on:
      - app  # web 服务启动前必须先启动 app 服务

  app:
    build: ./app  # 指定 Dockerfile 所在的目录来构建镜像
    volumes:
      - ./app:/usr/src/app  # 将宿主机的 ./app 目录挂载到容器内
    environment:
      DEBUG: "true"  # 设置环境变量

  db:
    image: postgres
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - pgdata:/var/lib/postgresql/data  # 使用命名卷来持久化数据库

volumes:
  pgdata:  # 定义一个命名卷

常用的 Docker Compose 命令

• 启动服务：在包含 docker-compose.yml 文件的目录中执行以下命令来启动所有服务：

  docker-compose up

  添加 -d 参数可以在后台运行：

  docker-compose up -d

• 查看服务状态：

  docker-compose ps

• 查看服务日志：

  docker-compose logs

• 停止服务：

  docker-compose stop

• 删除服务：停止并删除所有容器及网络资源，但保留数据卷。

  docker-compose down

  若要同时删除数据卷，可以使用 --volumes 选项：

  docker-compose down --volumes

使用场景

Docker Compose 非常适合本地开发和测试环境，因为它可以轻松地启动、停止和重建服务。在生产环境中，尽管也可以使用 Docker Compose，但对于大规模部署，更复杂的系统如 Kubernetes 或 Docker Swarm 通常更为合适，因为它们提供了更高级的管理功能和可伸缩性。

通过使用 Docker Compose，开发团队可以确保不同环境中的一致性，极大地简化了部署和管理多容器应用的复杂性。

Docker进阶应用

Docker Swarm和Kubernetes的基本概念（容器编排）

Docker Swarm 和 Kubernetes 都是容器编排工具，用于管理和调度大量容器的部署、扩展和运行。这些工具提供了高可用性、可伸缩性、负载均衡和自动化部署等功能，从而简化了容器化应用在生产环境中的管理。

Docker Swarm

Docker Swarm 是 Docker 官方的容器编排工具，设计上完全集成到了 Docker 生态系统中。

基本概念

• Swarm Mode：当 Docker 在 swarm 模式下运行时，它可以管理多个 Docker 主机，并将它们作为一个集群来管理。Docker Swarm 提供了原生的集群管理和编排功能。
• 节点（Nodes）：Swarm 集群由多个节点组成，节点可以是物理或虚拟的机器。节点分为两种类型：管理节点（Managers）和工作节点（Workers）。管理节点负责集群管理任务（如维护集群状态、调度服务等），而工作节点则负责运行容器实例。
• 服务（Services）：在 Docker Swarm 中，服务代表了在集群中部署的一个应用或容器的配置。一个服务定义了使用的容器镜像、命令、副本数量等信息。

特点

• 简易性：相对于 Kubernetes，Docker Swarm 更易于设置和维护，特别是对于较小规模的生产部署或者较少容器化知识的团队。
• 直接集成：与 Docker 强集成，无需额外安装即可启动和运行。
• 负载均衡：自动内部负载均衡，容易配置服务的发布端口。

Kubernetes

Kubernetes（通常称为 K8s）是由 Google 开发并后来捐赠给 Cloud Native Computing Foundation（CNCF）的开源容器编排平台。

基本概念

• 集群（Cluster）：Kubernetes 通过集群来管理多个主机上的容器化应用。集群包含至少一个主节点（Master Node）和多个工作节点（Worker Node）。
• Pod：Kubernetes 的基本运行单位是 Pod，一个 Pod 可以包含一个或多个容器（通常是紧密关联的容器）。
• 控制器（Controllers）：例如部署（Deployments），控制器确保指定数量的 Pod 副本始终处于运行状态。当 Pod 失败或被删除时，控制器会自动替换它们。
• 服务（Service）：服务是定义一组逻辑上相关联的 Pod 访问规则的抽象方式，通常用于内部负载均衡和服务发现。

特点

• 强大的自动化：支持自动部署、自动修复、扩展、滚动更新等。
• 广泛的生态系统：支持多种数据卷、秘钥管理、配置管理的解决方案。
• 高可扩展性：适用于非常大规模的应用部署。

对比

• 复杂性：Kubernetes 比 Docker Swarm 更复杂，需要更多的设置和维护工作，但它提供了更高的灵活性和更强的功能，特别是在大规模部署和跨云环境中。
• 社区和生态：Kubernetes 拥有更大的社区支持和更丰富的生态系统，有更多的工具和扩展支持。
• 适用性：Docker Swarm 适合小到中型部署，或者是对 Docker 生态系统有较深入使用的团队。而 Kubernetes 适合需要复杂操作和自动化的大规模生产环境。

选择哪一个平台取决于你的具体需求、团队的技能水平、预期的运维负担以及未来的扩展需求

Docker在CI/CD流程中的作用

Docker 在持续集成（CI）和持续部署（CD）流程中扮演着关键角色，极大地增强了软件开发和部署的效率和一致性。通过使用 Docker，团队能够更容易地创建、测试和部署应用，确保在各种环境中应用的一致性和可靠性。

1. 环境一致性

Docker 容器提供了高度一致的运行环境，这意味着软件无论在开发者的本地机器、测试环境还是生产环境中运行，都处于相同的环境配置中。这消除了常见的“在我的机器上可以运行”问题，减少了环境差异带来的风险。

2. 快速、可重复的构建

Docker 容器可以在几秒内启动，这使得启动新的应用实例变得非常快速和低成本。每个 Docker 镜像都可以定义一次并在多个环节中重复使用，确保了构建过程的可重复性。这对于自动化构建和测试流程尤其重要。

3. 隔离和安全

在持续集成过程中，Docker 允许每个应用或测试实例在独立的容器中运行，从而彼此隔离。这不仅提高了安全性，还允许并行执行多个构建或测试过程，从而提高了效率。

4. 微服务架构

对于采用微服务架构的应用，Docker 提供了一个理想的解决方案，用于管理和部署众多独立服务。每个服务可以封装在自己的容器中，独立开发、测试和部署，Docker 与 Kubernetes 或 Docker Swarm 这样的容器编排工具结合使用，可以有效管理服务的生命周期。

5. 自动化部署

在持续部署阶段，Docker 容器可以通过简单的命令进行部署和升级，结合容器编排工具，可以实现无缝的滚动更新、回滚等高级部署策略。Docker 镜像一旦构建完成，可以被推送到镜像仓库，并可被任何有权限的环境拉取和部署。

6. 集成与交付

Docker 容器易于与现有的 CI/CD 工具（如 Jenkins、GitLab CI、CircleCI 等）集成。构建过程中生成的容器镜像可以直接推送到 Docker Hub 或私有仓库，供后续流程使用。

实例应用

在实际的 CI/CD 流程中，你可能会看到如下步骤：

1. 代码提交：开发者提交代码到版本控制系统。
2. 自动构建：CI 工具触发构建，使用 Docker 构建一个包含新代码的镜像。
3. 自动测试：运行自动化测试，测试可能在独立的 Docker 容器中运行，以保证测试环境的干净和一致。
4. 部署到测试环境：如果构建和测试成功，自动将 Docker 镜像部署到测试环境。
5. 人工审核和部署到生产：通过审核后，使用相同的 Docker 镜像部署到生产环境。

通过使用 Docker，CI/CD 流程得到了极大的简化和加速，同时也提高了软件交付的质量和可靠性。

实践：实现一个基本的CI/CD流程，使用Docker

实现一个基本的 CI/CD 流程使用 Docker 的关键在于自动化代码从开发到生产的整个部署过程。以下是使用 Docker 实现 CI/CD 流程的步骤，涵盖代码提交、自动化构建、测试、部署等关键环节。

第 1 步：准备基础设施

1. 版本控制系统：例如 Git。所有的代码更改都应提交到版本控制系统中，触发 CI/CD 流程。
2. CI/CD 工具：如 Jenkins、GitLab CI、GitHub Actions 等，用于自动化执行构建、测试和部署的任务。
3. Docker 环境：在 CI/CD 服务器（可能是虚拟机或物理服务器）上安装 Docker。

第 2 步：配置 Dockerfile

为你的应用创建一个 Dockerfile，这是一个文本文件，包含了所有的命令，用于构建出一个包含你的应用及其所有依赖的 Docker 镜像。

# 基础镜像
FROM node:14

# 创建工作目录
WORKDIR /app

# 复制 package.json 并安装依赖
COPY package.json ./
RUN npm install

# 复制所有源代码
COPY . .

# 暴露端口
EXPOSE 3000

# 启动命令
CMD ["npm", "start"]

第 3 步：设置 CI/CD 流水线

在你的 CI/CD 工具中配置流水线。以 GitLab CI 为例，你需要在项目根目录下创建一个 .gitlab-ci.yml 文件来定义构建和部署的步骤：

stages:
  - build
  - test
  - deploy

build:
  stage: build
  script:
    - docker build -t myapp:$CI_COMMIT_SHORT_SHA .
  tags:
    - docker

test:
  stage: test
  script:
    - docker run myapp:$CI_COMMIT_SHORT_SHA npm test
  tags:
    - docker

deploy:
  stage: deploy
  script:
    - docker push myapp:$CI_COMMIT_SHORT_SHA
    - ssh deploy@server "docker pull myapp:$CI_COMMIT_SHORT_SHA && docker run -d --rm -p 80:3000 myapp:$CI_COMMIT_SHORT_SHA"
  only:
    - master
  tags:
    - docker

说明：

• 构建阶段：使用 Dockerfile 构建 Docker 镜像。
• 测试阶段：运行 Docker 容器来执行测试。
• 部署阶段：将镜像推送到 Docker 仓库（如 Docker Hub），然后通过 SSH 连接到生产服务器，拉取最新镜像并运行容器。

第 4 步：部署和运维

• 自动化部署：当推送到主分支时，自动化脚本触发部署流程，部署最新版本到生产环境。
• 监控和日志：确保生产环境有监控和日志收集系统，以便于跟踪错误和性能问题。

第 5 步：测试和反馈

• 回滚策略：确保可以快速回滚至之前的版本，如果新部署的版本出现问题。
• 持续改进：基于监控系统和用户反馈持续优化 CI/CD 流程和应用性能。

通过这种方式，Docker 在 CI/CD 流程中提供了环境一致性和便捷的部署方式，大大提高了开发效率和应用部署的可靠性。