2.1 理解 Docker 容器

欢迎来到 Docker 容器的世界！这一节将带你深入了解 Docker 容器的核心概念，帮助你掌握如何在实际工作中高效使用它们。

2.1.1 重点基础知识

深入理解 Docker 容器是掌握 Docker 的关键。下面我们将详细讲解有关 Docker 容器的一些核心概念，帮助你在实际工作中更加高效地使用 Docker。

1. Docker 容器的本质:

   • Docker 容器实际上是在主机操作系统上运行的一个隔离的进程。它们与主机共享内核，但运行在自己的隔离环境中。
   • 容器相比于传统的虚拟化技术更加轻量，因为它们不需要为每个实例运行一个完整的操作系统。

2. 容器与镜像的区别:

   • 镜像是一个只读的模板，包含了创建容器所需的代码、库、环境变量和配置文件。
   • 容器是镜像的运行实例。当你启动镜像时，它在容器中运行。容器是可写的，任何对容器的修改都是在镜像的基础上进行的。

3. 容器的隔离性和安全性:

   • Docker 利用 Linux 的命名空间（namespaces）和控制组（cgroups）等特性来提供容器的隔离。
   • 命名空间确保容器内的进程不会影响主机或其他容器。控制组限制容器可以使用的资源量（如 CPU、内存）。

4. 容器状态管理:

   • 你可以通过命令来管理容器的生命周期，包括创建（docker run）、启动（docker start）、停止（docker stop）、重启（docker restart）和删除（docker rm）容器。
   • 使用 docker ps 命令可以查看当前运行的容器，而 docker ps -a 显示所有容器，包括未运行的。

5. 容器数据管理:

   • 容器通常被用于短暂的任务，因此它们的数据是易失的。为了持久化数据，Docker 提供了卷（volumes）的概念，允许你将数据存储在容器外部，确保数据的持久化。
   • 卷可以在多个容器间共享和重用，也可以用于备份、恢复和迁移数据。

理解这些核心概念后，你将能够更有效地使用 Docker 容器来部署和管理你的应用。容器不仅提高了应用的部署效率，也为开发和运维带来了极大的便利。在接下来的案例中，我们将具体展示如何在实际工作中应用这些知识。

2.1.2 重点案例：使用 Docker 运行 Python 应用

在这个案例中，我们将通过一个具体的示例来展示如何使用 Docker 运行一个简单的 Python 应用。这个应用将包括一个简单的 Python 脚本，它在 Docker 容器中执行并输出一条信息。

步骤 1: 创建 Python 脚本

首先，我们创建一个简单的 Python 脚本。在你的工作目录中，创建一个名为 hello.py 的文件，并添加以下内容：

# hello.py
print("Hello, Docker World!")

这个脚本仅仅打印出一条欢迎信息。

步骤 2: 编写 Dockerfile

接下来，我们需要编写一个 Dockerfile 来定义如何在 Docker 容器中运行这个脚本。在你的工作目录中，创建一个名为 Dockerfile 的文件，并添加以下内容：

# 使用官方 Python 镜像作为基础镜像
FROM python:3.8# 将工作目录设置为 /app
WORKDIR /app# 将当前目录中的文件复制到容器的 /app 目录
COPY hello.py /app/# 定义容器启动时执行的命令
CMD ["python", "./hello.py"]

这个 Dockerfile 从 Python 3.8 镜像开始，设置了工作目录，并将 hello.py 脚本复制到容器中。最后，它指定了容器启动时执行的命令。

步骤 3: 构建 Docker 镜像

使用以下命令来构建 Docker 镜像：

docker build -t hello-python .

这个命令会根据 Dockerfile 构建一个名为 hello-python 的镜像。

步骤 4: 运行 Docker 容器

构建完镜像后，我们可以运行一个基于该镜像的容器：

docker run hello-python

执行这个命令后，Docker 会启动一个新的容器实例，容器会运行 hello.py 脚本，并在控制台输出 “Hello, Docker World!” 的消息。

通过这个简单的案例，你可以看到 Docker 如何帮助我们轻松地运行一个 Python 应用。这个过程展示了从编写脚本、创建 Dockerfile 到构建镜像和运行容器的完整流程，是理解 Docker 容器化应用的基础。

2.1.3 拓展案例 1：Docker 中的 Flask 应用

在这个案例中，我们将展示如何使用 Docker 来部署一个 Flask Web 应用。这个示例将帮助你理解如何将一个 Python Web 应用容器化，并在 Docker 环境中运行它。

步骤 1: 创建 Flask 应用

首先，我们创建 Flask 应用的基本代码。在你的工作目录中，创建两个文件：app.py 和 requirements.txt。

• app.py - Flask 应用的主文件：

  # app.py
  from flask import Flaskapp = Flask(__name__)@app.route('/')
  def home():return 'Welcome to the Dockerized Flask App!'if __name__ == '__main__':app.run(debug=True, host='0.0.0.0')
  

  这段代码创建了一个 Flask 应用，它在根 URL (/) 上返回欢迎信息。

• requirements.txt - Python 依赖文件：

  flask
  

步骤 2: 编写 Dockerfile

创建一个 Dockerfile 来定义 Flask 应用的容器化。在你的工作目录中，创建一个名为 Dockerfile 的文件，并添加以下内容：

# 使用官方 Python 镜像作为基础镜像
FROM python:3.8# 设置工作目录
WORKDIR /app# 将当前目录中的文件复制到容器的 /app 目录
COPY . /app# 安装依赖
RUN pip install --no-cache-dir -r requirements.txt# 暴露端口 5000
EXPOSE 5000# 定义容器启动时执行的命令
CMD ["python", "app.py"]

步骤 3: 构建 Docker 镜像

使用以下命令来构建 Docker 镜像：

docker build -t flask-app .

这个命令会根据 Dockerfile 构建一个名为 flask-app 的镜像。

步骤 4: 运行 Docker 容器

运行以下命令来启动 Flask 应用：

docker run -p 5000:5000 flask-app

这个命令会启动一个新的容器实例，并将容器的 5000 端口映射到主机的 5000 端口。

现在，你的 Flask 应用已经在 Docker 容器中运行。你可以通过访问 http://localhost:5000 来查看应用的输出。

通过这个案例，你可以看到如何将 Flask 应用容器化，并在 Docker 中运行它。这种方式不仅使应用的部署变得简单，还确保了在不同环境中的一致性和可移植性。这对于开发和测试团队来说是一个巨大的优势。

2.1.4 拓展案例 2：Docker 容器中的数据分析

在这个案例中，我们将演示如何在 Docker 容器内设置一个用于 Python 数据分析的环境，具体包括 Jupyter Notebook 以及常用的数据科学库，如 Pandas 和 NumPy。这种方式非常适合数据科学家和分析师，因为它提供了一个可重复、易于分享的工作环境。

步骤 1: 编写 Dockerfile

首先，我们需要编写一个 Dockerfile 来定义数据分析环境。在你的工作目录中，创建一个名为 Dockerfile 的文件，并添加以下内容：

# 从官方 Python 镜像开始构建
FROM python:3.8-slim# 安装 Jupyter Notebook 和数据分析库
RUN pip install notebook pandas numpy matplotlib seaborn# 设置工作目录为 /workspace
WORKDIR /workspace# 暴露 Jupyter Notebook 运行的端口
EXPOSE 8888# 启动 Jupyter Notebook
CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]

这个 Dockerfile 从 Python 3.8 镜像开始，安装了 Jupyter Notebook 和常见的数据分析库，然后设置了工作目录，并定义了启动 Jupyter Notebook 的命令。

步骤 2: 构建 Docker 镜像

接下来，使用以下命令来构建 Docker 镜像：

docker build -t python-data-analysis .

这个命令会根据 Dockerfile 构建一个名为 python-data-analysis 的镜像。

步骤 3: 运行 Docker 容器

现在，我们可以运行这个镜像：

docker run -p 8888:8888 python-data-analysis

这个命令启动了一个 Docker 容器，并将本地机器的 8888 端口映射到容器的 8888 端口。容器启动后，Jupyter Notebook 将在指定端口运行。

在容器运行后，命令行会显示一个 URL，包含访问 Jupyter Notebook 的 token。复制这个 URL 到浏览器中，你就可以开始在 Jupyter Notebook 中进行数据分析了。

数据分析示例

在 Jupyter Notebook 中，你可以创建一个新的笔记本来编写 Python 代码，进行数据分析。例如，你可以使用以下代码来分析一些简单的数据集，并使用 Matplotlib 进行可视化：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt# 创建简单的数据集
data = pd.DataFrame({'x': range(1, 11),'y': np.random.randn(10)
})# 使用 Matplotlib 绘制图表
plt.plot(data['x'], data['y'], marker='o')
plt.title('Random Data Visualization')
plt.xlabel('X Axis')
plt.ylabel('Y Axis')
plt.grid(True)
plt.show()

通过这个案例，你可以看到 Docker 如何帮助我们快速搭建一个完整的数据分析环境，无论你身在何处，都能保证环境的一致性和可移植性。这对于数据科学家和分析师来说是一个巨大的优势，特别是在进行协作和远程工作时。

通过这些案例，你将能够深入理解 Docker 容器的工作原理，并学会如何在实际工作中应用它们。不论是简单的 Python 脚本，还是复杂的 Web 应用和数据分析项目，Docker 都能为你提供一致且灵活的运行环境。

2.2 创建与管理 Docker 镜像

在 Docker 的世界里，镜像是一切的基础。本节我们将深入了解 Docker 镜像的创建和管理，探索如何制作自己的 Docker 镜像并高效管理它们。

2.2.1 重点基础知识

深入理解 Docker 镜像的创建和管理对于有效使用 Docker 来说至关重要。以下是关于 Docker 镜像的一些核心概念和操作的详细讲解：

1. Docker 镜像的核心概念:

   • Docker 镜像是一个包含应用及其依赖和环境的轻量级、不可变的、可执行包。
   • 镜像是由一系列层（layers）构成的，每一层代表 Dockerfile 中的一个指令。层被缓存，使得重复构建镜像更加快速高效。

2. 创建 Dockerfile:

   • Dockerfile 是创建 Docker 镜像的蓝图，其中包含了一系列指令，每个指令都添加一个新的层到镜像中。
   • 常用指令包括：
     • FROM: 定义基础镜像，所有后续指令都基于这个镜像。
     • RUN: 在镜像中运行命令，通常用于安装软件包。
     • COPY 和 ADD: 将文件从宿主机复制到镜像中。
     • CMD: 指定容器启动时默认执行的命令。
     • EXPOSE: 声明容器运行时监听的端口。
     • ENV: 设置环境变量。

3. 构建镜像:

   • 使用 docker build 命令根据 Dockerfile 来创建镜像。例如，docker build -t my-app . 会创建一个名为 my-app 的镜像。
   • 构建上下文（即 docker build 命令后的 .）是 Dockerfile 所在目录，Docker 会将这个目录下的所有内容发送给 Docker daemon 来构建镜像。

4. 优化镜像构建:

   • 使用 .dockerignore 文件来排除不需要复制到镜像中的文件，减少构建上下文的大小，加速镜像构建过程。
   • 通过合理安排 Dockerfile 指令顺序和利用层缓存机制来优化构建过程。

5. 镜像存储和仓库:

   • 镜像可以存储在本地，也可以推送到远程仓库（如 Docker Hub 或私有仓库）以便共享。
   • 使用 docker push 命令将镜像推送到仓库，使用 docker pull 命令从仓库拉取镜像。

通过理解这些基础知识，你将能够有效地创建和管理 Docker 镜像，为你的应用和服务提供坚实的基础。在接下来的案例中，我们将进一步展示这些知识在实际应用中的运用。

2.2.2 重点案例：创建 Python 应用的 Docker 镜像

在这个案例中，我们将创建一个简单的 Python 应用的 Docker 镜像。这个 Python 应用将执行一个简单的任务，比如打印一条消息。我们将从编写一个 Python 脚本开始，接着创建一个 Dockerfile，然后构建并运行 Docker 镜像。

步骤 1: 创建 Python 脚本

首先，我们需要一个 Python 脚本作为我们应用的核心。在你的工作目录中，创建一个名为 main.py 的文件，并添加以下内容：

# main.py
print("Hello from Python Dockerized App!")

这个脚本简单地打印出一条欢迎信息。

步骤 2: 编写 Dockerfile

然后，我们需要创建一个 Dockerfile 来定义如何将这个 Python 脚本打包成一个 Docker 镜像。在你的工作目录中，创建一个名为 Dockerfile 的文件，并添加以下内容：

# 使用官方 Python 镜像作为基础镜像
FROM python:3.8# 设置工作目录为 /app
WORKDIR /app# 将当前目录中的文件复制到容器的 /app 目录
COPY main.py /app/# 定义容器启动时执行的命令
CMD ["python", "./main.py"]

这个 Dockerfile 使用了官方的 Python 3.8 镜像作为基础镜像，设置了工作目录，并将我们的 main.py 脚本复制到了镜像中。CMD 指令定义了容器启动时需要执行的命令。

步骤 3: 构建 Docker 镜像

接下来，我们将使用以下命令来构建 Docker 镜像：

docker build -t python-app .

这个命令告诉 Docker 构建一个新的镜像，并将其标记为 python-app。

步骤 4: 运行 Docker 容器

一旦镜像构建完成，我们可以运行一个基于该镜像的容器：

docker run python-app

执行这个命令后，Docker 会启动一个新的容器实例，容器会运行 main.py 脚本，并在控制台输出 “Hello from Python Dockerized App!”。

通过这个案例，你学会了如何创建一个简单的 Python 应用的 Docker 镜像，并运行它。这个过程展示了从编写应用代码、创建 Dockerfile 到构建和运行 Docker 镜像的完整流程，为进一步使用 Docker 部署更复杂的应用奠定了基础。

2.2.3 拓展案例 1：多阶段构建的 Flask 应用

在这个案例中，我们将使用 Docker 的多阶段构建功能来创建一个轻量级的 Flask 应用镜像。多阶段构建是一种优化 Docker 镜像的方法，它允许你在一个 Dockerfile 中使用多个构建阶段，但只将最后阶段的结果保存为最终镜像，从而减小镜像的大小。

步骤 1: 创建 Flask 应用

首先，我们需要创建 Flask 应用的基本代码。在你的工作目录中，创建两个文件：app.py 和 requirements.txt。

• app.py - Flask 应用的主文件：

  # app.py
  from flask import Flaskapp = Flask(__name__)@app.route('/')
  def home():return 'Welcome to the Multi-Stage Dockerized Flask App!'if __name__ == '__main__':app.run(debug=True, host='0.0.0.0')
  

  这段代码创建了一个 Flask 应用，它在根 URL (/) 上返回一个欢迎消息。

• requirements.txt - Python 依赖文件：

  flask
  

步骤 2: 编写多阶段 Dockerfile

接下来，我们创建一个使用多阶段构建的 Dockerfile。在你的工作目录中，创建一个名为 Dockerfile 的文件，并添加以下内容：

# 第一阶段：构建阶段
FROM python:3.8-slim AS builder# 设置工作目录
WORKDIR /app# 将依赖文件复制到容器中
COPY requirements.txt .# 安装依赖
RUN pip install --user -r requirements.txt# 第二阶段：运行阶段
FROM python:3.8-slim# 设置工作目录
WORKDIR /app# 从构建阶段复制应用
COPY --from=builder /root/.local /root/.local
COPY app.py .# 确保使用的是局部安装的包
ENV PATH=/root/.local:$PATH# 暴露端口 5000
EXPOSE 5000# 定义容器启动时执行的命令
CMD ["python", "app.py"]

在这个 Dockerfile 中，我们有两个阶段：构建阶段和运行阶段。在构建阶段，我们安装了所有依赖。在运行阶段，我们从构建阶段复制了安装好的依赖，减少了最终镜像的大小。

步骤 3: 构建 Docker 镜像

使用以下命令来构建 Docker 镜像：

docker build -t multistage-flask-app .

这个命令会根据多阶段 Dockerfile 构建一个名为 multistage-flask-app 的镜像。

步骤 4: 运行 Docker 容器

运行以下命令来启动 Flask 应用：

docker run -p 5000:5000 multistage-flask-app

这个命令会启动一个新的容器实例，并将容器的 5000 端口映射到主机的 5000 端口。

现在，你的 Flask 应用已经在 Docker 容器中运行。你可以通过访问 http://localhost:5000 来查看应用的输出。

这个案例展示了如何使用多阶段构建来优化 Flask 应用的 Docker 镜像。这种方法不仅减少了镜像的大小，还保持了镜像的清洁和高效。对于生产环境中的部署来说，这是一个非常实用的优化策略。

2.2.4 拓展案例 2：为数据科学项目创建 Docker 镜像

这个案例将指导你如何为一个包含 Jupyter Notebook 和数据科学相关库的项目创建 Docker 镜像。这对于确保数据科学项目的环境一致性和便于分享非常有用。

步骤 1: 准备项目文件

我们将创建一个简单的数据分析项目，使用 Jupyter Notebook 和一些常用的数据科学库。在你的工作目录中，创建一个名为 requirements.txt 的文件，并添加以下内容：

jupyter
pandas
numpy
matplotlib
scipy
seaborn

这些是我们将在项目中使用的 Python 数据科学库。

步骤 2: 编写 Dockerfile

接下来，我们编写 Dockerfile 来定义项目的 Docker 镜像。在你的工作目录中，创建一个名为 Dockerfile 的文件，并添加以下内容：

# 使用官方 Python 镜像作为基础镜像
FROM python:3.8# 安装 requirements.txt 中的所有依赖
COPY requirements.txt /
RUN pip install --no-cache-dir -r /requirements.txt# 设置工作目录
WORKDIR /workspace# 暴露 Jupyter Notebook 运行的端口
EXPOSE 8888# 启动 Jupyter Notebook
CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]

此 Dockerfile 使用 Python 3.8 镜像为基础，安装了 requirements.txt 中指定的所有数据科学库，并配置 Jupyter Notebook 运行所需的设置。

步骤 3: 构建 Docker 镜像

使用以下命令来构建 Docker 镜像：

docker build -t data-science-project .

这个命令会根据 Dockerfile 构建一个名为 data-science-project 的镜像。

步骤 4: 运行 Docker 容器

运行以下命令来启动包含数据科学环境的容器：

docker run -p 8888:8888 data-science-project

这个命令启动了一个新的容器实例，并将容器的 8888 端口映射到主机的 8888 端口。容器启动后，Jupyter Notebook 将在该端口上运行。

在容器运行后，你将在命令行中看到一个 URL，其中包含了访问 Jupyter Notebook 的 token。复制这个 URL 到浏览器中，你就可以开始使用 Jupyter Notebook 进行数据分析了。

数据分析示例

在 Jupyter Notebook 中，你可以创建新的笔记本来执行数据分析任务。例如，你可以导入 Pandas 和 Matplotlib 来分析和可视化一个数据集。

通过这个案例，你可以看到如何为数据科学项目创建一个专用的 Docker 镜像。这种方法不仅有助于确保项目环境的一致性，也便于在不同环境中复制和共享你的工作。

通过这些案例，你将学会如何创建、管理和优化 Docker 镜像，从而为你的 Python 应用提供高效、可靠的运行环境。这些技能在现代软件开发和数据科学领域具有极高的实用价值。

2.3 镜像存储与分发

Docker 镜像的存储与分发是 Docker 使用过程中的一个重要环节。它涉及到如何管理和共享你的 Docker 镜像。让我们深入了解这部分的基础知识和实用操作。

2.3.1 重点基础知识

进一步深入了解 Docker 镜像的存储与分发机制，可以帮助你更有效地管理和共享 Docker 镜像，这对于现代软件开发和运维非常重要。

1. 镜像存储细节:

   • Docker 使用层叠的方式存储镜像。当你构建一个镜像时，每一个命令都会创建一个新的层。
   • 这些层是只读的，并且被缓存，这样在重新构建镜像时，已有的层可以被复用，提高构建效率。
   • 当容器基于镜像运行时，Docker 会在最顶层添加一个可写层。

2. 镜像版本控制:

   • 镜像标签（tags）通常用于管理不同版本的镜像。例如，你可以使用标签来区分开发、测试和生产环境的镜像版本。
   • 标签也可以用于版本控制，例如 my-app:v1.0、my-app:v2.0 等。

3. 镜像仓库的类型:

   • 公共仓库：如 Docker Hub，任何人都可以下载和使用其中的镜像。对于开源项目或公共可用的服务来说非常适用。
   • 私有仓库：仅限特定用户访问。企业通常使用私有仓库来保护商业秘密和保证安全性。

4. 推送和拉取镜像的安全性:

   • 在推送和拉取镜像时，需要考虑安全性。使用 HTTPS 和其他安全协议可以保护镜像的传输过程。
   • 对于敏感数据，不应直接包含在镜像中。可以使用 Docker secret 或环境变量等机制来安全地管理敏感数据。

5. Docker Registry:

   • Docker Registry 是存储 Docker 镜像的服务。Docker Hub 是最常用的 Docker Registry，但也有其他选项，如 AWS ECR、Azure Container Registry 等。
   • 你可以设置自己的私有 Docker Registry，以更好地控制镜像的存储和分发。

了解这些关于 Docker 镜像存储与分发的核心概念，可以帮助你更有效地利用 Docker，无论是在开发、测试还是在生产环境中。接下来，我们将通过具体案例，演示如何将这些知识应用到实际场景中。

2.3.2 重点案例：上传 Python 应用镜像到 Docker Hub

在这个案例中，我们将创建一个简单的 Python 应用的 Docker 镜像，并将其上传到 Docker Hub。这个过程展示了如何将本地创建的镜像分享到公共仓库，使得它可以被其他人下载和使用。

步骤 1: 创建 Python 应用

首先，我们需要一个 Python 应用。在你的工作目录中，创建一个名为 app.py 的文件，并添加以下内容：

# app.py
print("Hello from my Dockerized Python App!")

这个脚本只做一件事：打印一条欢迎信息。

步骤 2: 编写 Dockerfile

接下来，编写一个 Dockerfile 来定义如何将这个 Python 脚本打包到一个 Docker 镜像中。在你的工作目录中，创建一个名为 Dockerfile 的文件，并添加以下内容：

# 使用官方 Python 镜像作为基础镜像
FROM python:3.8# 将工作目录设置为 /app
WORKDIR /app# 将当前目录中的文件复制到容器的 /app 目录
COPY app.py /app/# 定义容器启动时执行的命令
CMD ["python", "./app.py"]

步骤 3: 构建 Docker 镜像

使用以下命令来构建 Docker 镜像，并为其添加合适的标签：

docker build -t my-username/my-python-app .

这里的 my-username 应该替换为你在 Docker Hub 上的用户名，my-python-app 是你为镜像选择的名称。

步骤 4: 登录到 Docker Hub

在上传镜像之前，你需要登录到 Docker Hub。使用以下命令并输入你的 Docker Hub 凭据：

docker login

步骤 5: 将镜像推送到 Docker Hub

一旦登录成功，使用以下命令将镜像推送到 Docker Hub：

docker push my-username/my-python-app

推送完成后，你的镜像现在可以在 Docker Hub 上被其他用户访问和使用了。

通过这个案例，你不仅学会了如何创建和管理本地 Docker 镜像，还学会了如何将它们分享给全世界。这对于推广你的项目、协作开发或者仅仅是分享你的创造来说都是非常有价值的。

2.3.3 拓展案例 1：从 Docker Hub 拉取并运行镜像

在这个案例中，我们将演示如何从 Docker Hub 拉取一个已经存在的 Python 应用镜像，并在本地运行它。这个过程展示了如何利用 Docker Hub 作为资源库来获取和使用他人创建的 Docker 镜像。

步骤 1: 选择一个 Python 应用镜像

假设我们想要运行一个公共的 Python 应用镜像，例如一个简单的 Flask Web 应用。首先，我们需要在 Docker Hub 中找到这样一个合适的镜像。这里，我们假设找到了一个名为 example-user/flask-app 的镜像。

步骤 2: 从 Docker Hub 拉取镜像

使用以下命令从 Docker Hub 拉取你选择的镜像：

docker pull example-user/flask-app

这个命令会从 Docker Hub 下载 example-user/flask-app 镜像到你的本地机器。

步骤 3: 在本地运行镜像

一旦镜像被成功拉取，你可以像运行任何其他 Docker 镜像一样运行它。如果这个 Flask 应用假设运行在端口 5000 上，你可以使用以下命令来运行它：

docker run -p 5000:5000 example-user/flask-app

这个命令启动了一个基于拉取的镜像的容器，并将容器的 5000 端口映射到了你的主机的 5000 端口。

步骤 4: 访问应用

现在，Flask 应用应该在你的 Docker 容器中运行着。你可以通过访问 http://localhost:5000 来查看应用的输出。

通过这个案例，你可以看到 Docker 如何使得获取和运行他人创建的应用变得非常简单。这对于快速部署测试应用或者学习他人如何构建和配置 Docker 镜像来说非常有用。

2.3.4 拓展案例 2：使用私有 Docker 仓库

在这个案例中，我们将演示如何使用私有 Docker 仓库来存储和分发 Docker 镜像。私有仓库非常适合存储企业内部使用的镜像，以保护商业秘密和保证安全性。

步骤 1: 设置私有 Docker 仓库

假设我们使用 Docker Hub 的私有仓库功能，你首先需要在 Docker Hub 上创建一个账户（如果还没有的话），然后创建一个新的私有仓库。我们将这个仓库命名为 my-private-repo。

步骤 2: 创建 Python 应用

在你的工作目录中，创建一个简单的 Python 应用。创建一个名为 app.py 的文件，并添加以下内容：

# app.py
print("Hello from my private Docker repository!")

步骤 3: 编写 Dockerfile

为了将这个 Python 应用容器化，我们需要创建一个 Dockerfile。在你的工作目录中，创建一个名为 Dockerfile 的文件，并添加以下内容：

# 使用官方 Python 镜像作为基础镜像
FROM python:3.8# 将工作目录设置为 /app
WORKDIR /app# 将当前目录中的文件复制到容器的 /app 目录
COPY app.py /app/# 定义容器启动时执行的命令
CMD ["python", "./app.py"]

步骤 4: 构建 Docker 镜像

使用以下命令来构建 Docker 镜像，并为其添加合适的标签：

docker build -t my-username/my-private-repo:my-app .

这里的 my-username 应该替换为你在 Docker Hub 上的用户名，my-private-repo:my-app 是你为镜像选择的名称。

步骤 5: 登录到 Docker Hub

在上传镜像之前，你需要登录到 Docker Hub。使用以下命令并输入你的 Docker Hub 凭据：

docker login

步骤 6: 将镜像推送到私有仓库

一旦登录成功，使用以下命令将镜像推送到你的私有仓库：

docker push my-username/my-private-repo:my-app

推送完成后，你的镜像现在存储在私有仓库中，只有授权的用户可以访问。

通过这个案例，你学会了如何使用私有 Docker 仓库来存储和分发镜像。这种方法在企业环境中非常有用，它可以帮助你更好地控制镜像的访问权限，确保敏感数据的安全。

通过这些案例，你可以掌握 Docker 镜像存储、管理和分发的核心技能，无论是公共还是私有仓库，都能高效地与团队或社区分享你的 Docker 镜像。这对于现代的软件开发和运维工作来说至关重要。