《Docker 简易速速上手小册》第2章 容器和镜像(2024 最新版)

简介: 《Docker 简易速速上手小册》第2章 容器和镜像(2024 最新版)

85cfc4375fbc0741b913263677af6fa.png


2.1 理解 Docker 容器

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

2.1.1 重点基础知识

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

  1. Docker 容器的本质:
  • Docker 容器实际上是在主机操作系统上运行的一个隔离的进程。它们与主机共享内核,但运行在自己的隔离环境中。
  • 容器相比于传统的虚拟化技术更加轻量,因为它们不需要为每个实例运行一个完整的操作系统。
  1. 容器与镜像的区别:
  • 镜像是一个只读的模板,包含了创建容器所需的代码、库、环境变量和配置文件。
  • 容器是镜像的运行实例。当你启动镜像时,它在容器中运行。容器是可写的,任何对容器的修改都是在镜像的基础上进行的。
  1. 容器的隔离性和安全性:
  • Docker 利用 Linux 的命名空间(namespaces)和控制组(cgroups)等特性来提供容器的隔离。
  • 命名空间确保容器内的进程不会影响主机或其他容器。控制组限制容器可以使用的资源量(如 CPU、内存)。
  1. 容器状态管理:
  • 你可以通过命令来管理容器的生命周期,包括创建(docker run)、启动(docker start)、停止(docker stop)、重启(docker restart)和删除(docker rm)容器。
  • 使用 docker ps 命令可以查看当前运行的容器,而 docker ps -a 显示所有容器,包括未运行的。
  1. 容器数据管理:
  • 容器通常被用于短暂的任务,因此它们的数据是易失的。为了持久化数据,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.pyrequirements.txt

  • app.py - Flask 应用的主文件:
# app.py
from flask import Flask
app = 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 中的一个指令。层被缓存,使得重复构建镜像更加快速高效。
  1. 创建 Dockerfile:
  • Dockerfile 是创建 Docker 镜像的蓝图,其中包含了一系列指令,每个指令都添加一个新的层到镜像中。
  • 常用指令包括:
  • FROM: 定义基础镜像,所有后续指令都基于这个镜像。
  • RUN: 在镜像中运行命令,通常用于安装软件包。
  • COPYADD: 将文件从宿主机复制到镜像中。
  • CMD: 指定容器启动时默认执行的命令。
  • EXPOSE: 声明容器运行时监听的端口。
  • ENV: 设置环境变量。
  1. 构建镜像:
  • 使用 docker build 命令根据 Dockerfile 来创建镜像。例如,docker build -t my-app . 会创建一个名为 my-app 的镜像。
  • 构建上下文(即 docker build 命令后的 .)是 Dockerfile 所在目录,Docker 会将这个目录下的所有内容发送给 Docker daemon 来构建镜像。
  1. 优化镜像构建:
  • 使用 .dockerignore 文件来排除不需要复制到镜像中的文件,减少构建上下文的大小,加速镜像构建过程。
  • 通过合理安排 Dockerfile 指令顺序和利用层缓存机制来优化构建过程。
  1. 镜像存储和仓库:
  • 镜像可以存储在本地,也可以推送到远程仓库(如 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.pyrequirements.txt

  • app.py - Flask 应用的主文件:
# app.py
from flask import Flask
app = 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 会在最顶层添加一个可写层。
  1. 镜像版本控制:
  • 镜像标签(tags)通常用于管理不同版本的镜像。例如,你可以使用标签来区分开发、测试和生产环境的镜像版本。
  • 标签也可以用于版本控制,例如 my-app:v1.0my-app:v2.0 等。
  1. 镜像仓库的类型:
  • 公共仓库:如 Docker Hub,任何人都可以下载和使用其中的镜像。对于开源项目或公共可用的服务来说非常适用。
  • 私有仓库:仅限特定用户访问。企业通常使用私有仓库来保护商业秘密和保证安全性。
  1. 推送和拉取镜像的安全性:
  • 在推送和拉取镜像时,需要考虑安全性。使用 HTTPS 和其他安全协议可以保护镜像的传输过程。
  • 对于敏感数据,不应直接包含在镜像中。可以使用 Docker secret 或环境变量等机制来安全地管理敏感数据。
  1. 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 镜像。这对于现代的软件开发和运维工作来说至关重要。

目录
相关文章
|
2天前
|
运维 Kubernetes 持续交付
Docker与Kubernetes:容器化技术的黄金搭档
【6月更文挑战第10天】Docker和Kubernetes是容器化技术的黄金组合,Docker提供轻量级、可移植的容器引擎,简化应用部署,而Kubernetes作为容器编排系统,实现自动化部署、扩展和管理,确保高可用性和可扩展性。两者的协作使得容器化应用更高效、可靠,共同推动软件开发和运维的创新。
|
5天前
|
存储 缓存 开发工具
Docker|了解容器镜像层(1)
Docker|了解容器镜像层(1)
20 0
|
5天前
|
监控 Cloud Native 持续交付
实现容器集群轻松部署:Docker Swarm 集群管理解析
实现容器集群轻松部署:Docker Swarm 集群管理解析
|
5天前
|
网络安全 开发者 Docker
探索 Docker Machine:打造无缝多平台容器部署的利器
探索 Docker Machine:打造无缝多平台容器部署的利器
|
5天前
|
关系型数据库 持续交付 数据库
简化多容器应用部署:深入理解 Docker Compose
简化多容器应用部署:深入理解 Docker Compose
|
5天前
|
存储 持续交付 数据安全/隐私保护
实现镜像管理轻松搞定:Docker 仓库管理详解
实现镜像管理轻松搞定:Docker 仓库管理详解
|
5天前
|
安全 数据安全/隐私保护 Docker
Docker 容器连接:构建安全高效的容器化网络生态
Docker 容器连接:构建安全高效的容器化网络生态
|
5天前
|
Shell Docker 容器
深入探索Docker容器管理:常用命令一览(1)
深入探索Docker容器管理:常用命令一览(1)
|
7天前
|
Cloud Native Java Docker
java一分钟之-Docker化Java应用:Dockerfile与镜像构建
【6月更文挑战第6天】本文探讨了Docker在Java应用部署中的重要性,强调了Dockerfile在保证环境一致性和提升部署效率上的作用。Dockerfile是自动化构建Docker镜像的文本文件,它的使用能实现标准化、可重复性和透明度。文章指出了编写Dockerfile时的常见问题,如指令误用、镜像体积过大和安全性不足,并提供了相应的解决策略。通过一个Spring Boot应用的实战示例,展示了如何编写Dockerfile和构建镜像。总之,掌握Dockerfile和镜像构建技巧对于优化Java应用的云原生部署至关重要。
30 0
|
7天前
|
监控 NoSQL Redis
Redis哨兵,Redis哨兵核心功能如何一个云服务器完成6个节点的搭建-docker什么是docker是否可以把六个容器,都写到同一个ym配置中,一次都启动,不就直接保证互通问题了吗?
Redis哨兵,Redis哨兵核心功能如何一个云服务器完成6个节点的搭建-docker什么是docker是否可以把六个容器,都写到同一个ym配置中,一次都启动,不就直接保证互通问题了吗?