7.1 容器监控与日志

跟踪容器的表现就像是给它们安装了一个高级仪表盘，让你能够实时了解它们的健康状况和性能指标。让我们深入了解容器监控和日志的关键要素。

7.1.1 重点基础知识

深入了解容器监控与日志对于维护和优化容器化应用至关重要。这些工具和技术就像是容器世界的“健康检查仪器”，让你随时掌握应用的健康状况和表现。

1. 容器性能指标监控:

   • 资源使用情况：监控 CPU 使用率、内存消耗、磁盘 I/O 和网络流量等，了解每个容器的资源占用情况。
   • 服务响应时间：跟踪服务的响应时间和延迟，确保满足性能要求。

2. 日志收集和分析:

   • 集中式日志管理：将容器的日志数据集中存储和管理，便于检索和分析。
   • 日志分析工具：使用日志分析工具（如 Logstash、Fluentd）处理和分析日志，提取有用信息。

3. 监控工具的选择与应用:

   • Prometheus：一个开源监控系统，适合收集时间序列数据，与 Grafana 结合使用可进行数据可视化。
   • Grafana：用于可视化监控数据，能够展示 Prometheus 收集的指标。

4. 监控策略和告警系统:

   • 设定有效的监控策略，以覆盖不同的性能指标和日志事件。
   • 配置告警系统，当监控到关键指标超出正常范围时自动通知，如使用 Prometheus 的 Alertmanager。

5. 日志的安全与合规:

   • 确保日志处理符合安全和合规要求，特别是当涉及敏感数据时。
   • 使用加密和访问控制来保护存储和传输中的日志数据。

6. 容器诊断工具:

   • 掌握使用容器诊断工具（如 Docker stats、Docker logs）来实时监控容器状态和性能。

通过精通这些监控和日志管理的知识和技能，你将能够确保容器应用的稳定运行，及时响应各种性能问题和安全威胁，从而维持高效、可靠的运营状态。

7.1.2 重点案例：监控 Flask 应用

在这个案例中，我们将使用 Prometheus 和 Grafana 来监控一个 Flask 应用。我们将设置一个完整的监控系统，以实时跟踪 Flask 应用的性能和健康状况。

步骤 1: 创建 Flask 应用

首先，创建一个基本的 Flask 应用。在你的工作目录中，创建以下文件：

• app.py:

  # app.py
  from flask import Flask, request
  from prometheus_flask_exporter import PrometheusMetrics
  
  app = Flask(__name__)
  metrics = PrometheusMetrics(app)
  
  @app.route('/')
  def home():
      return "Welcome to the monitored Flask app!"
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  

• requirements.txt:

  flask
  prometheus_flask_exporter
  

步骤 2: 编写 Dockerfile

创建 Dockerfile 来构建 Flask 应用的镜像：

FROM python:3.8-slim
WORKDIR /app
COPY requirements.txt /app/
RUN pip install --no-cache-dir -r requirements.txt
COPY . /app/
CMD ["python", "app.py"]

步骤 3: 构建 Flask 应用的镜像

在包含 Dockerfile 的目录中运行以下命令：

docker build -t monitored-flask-app .

步骤 4: 运行 Flask 应用容器

docker run -d -p 5000:5000 --name flask-app monitored-flask-app

步骤 5: 配置 Prometheus

1. 创建 Prometheus 的配置文件 prometheus.yml:

   global:
     scrape_interval: 15s
   
   scrape_configs:
     - job_name: 'flask'
       static_configs:
         - targets: ['host.docker.internal:5000']
   

   注意：host.docker.internal 是 Docker 为访问宿主机网络提供的特殊 DNS 名称。

2. 运行 Prometheus 容器：

   docker run -d -p 9090:9090 -v $(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus
   

步骤 6: 配置 Grafana

运行 Grafana 容器：

docker run -d -p 3000:3000 grafana/grafana

步骤 7: 设置 Grafana

1. 访问 Grafana 仪表板（通常是 http://localhost:3000），使用默认的 admin/admin 登录。
2. 添加 Prometheus 作为数据源（URL 为 http://host.docker.internal:9090）。
3. 创建仪表板来展示 Flask 应用的性能指标。

通过这个案例，你学会了如何为 Flask 应用设置一个完整的监控系统，包括性能指标的收集、存储和可视化。这将极大地提高你对应用性能和健康状况的了解，并能够及时发现并处理潜在的问题。

7.1.3 拓展案例 1：使用 ELK Stack 收集和分析日志

在这个案例中，我们将通过 ELK Stack（Elasticsearch、Logstash 和 Kibana）来收集和分析 Flask 应用的日志。ELK Stack 是一种流行的日志管理解决方案，可以帮助你更有效地处理和分析大量日志数据。

步骤 1: 配置 Flask 应用以生成日志

确保 Flask 应用能够生成并输出日志。你可以使用 Flask 内置的日志记录，或者使用如 logging 模块来自定义日志输出。

• app.py (确保包含日志记录):

  # app.py
  import logging
  from flask import Flask
  
  app = Flask(__name__)
  
  @app.route('/')
  def home():
      app.logger.info('Home route accessed')
      return "Welcome to the Flask app with logging!"
  
  if __name__ == '__main__':
      logging.basicConfig(level=logging.INFO)
      app.run(debug=True, host='0.0.0.0', port=5000)
  

步骤 2: 构建 Flask 应用的镜像

使用之前创建的 Dockerfile 构建 Flask 应用的镜像。

步骤 3: 部署 ELK Stack

1. 使用 Docker Compose 来启动 ELK Stack。创建 docker-compose.elk.yml:

   version: '3'
   services:
     elasticsearch:
       image: elasticsearch:7.10.0
       environment:
         - discovery.type=single-node
       ports:
         - "9200:9200"
     logstash:
       image: logstash:7.10.0
       ports:
         - "5000:5000"
       volumes:
         - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf
     kibana:
       image: kibana:7.10.0
       ports:
         - "5601:5601"
   

2. 创建 Logstash 的配置文件 logstash.conf:

   input {
     tcp {
       port => 5000
       codec => json
     }
   }
   output {
     elasticsearch {
       hosts => ["elasticsearch:9200"]
     }
   }
   

3. 启动 ELK Stack:

   docker-compose -f docker-compose.elk.yml up -d
   

步骤 4: 运行 Flask 应用并连接到 Logstash

运行 Flask 应用并配置它将日志发送到 Logstash：

docker run -d -p 5000:5000 --name flask-app --log-driver=syslog --log-opt syslog-address=tcp://host.docker.internal:5000 --log-opt syslog-format=rfc5424micro monitored-flask-app

步骤 5: 分析日志

1. 访问 Kibana 仪表板（通常是 http://localhost:5601）来查看和分析 Flask 应用产生的日志。
2. 在 Kibana 中，配置索引模式并创建可视化和仪表板以更好地理解日志数据。

通过这个案例，你将学会如何使用 ELK Stack 收集、存储和分析 Flask 应用的日志。这不仅有助于故障排查，还能提供应用性能和用户行为的深入见解。

7.1.4 拓展案例 2：使用集成监控工具

在这个案例中，我们将使用 Datadog 作为集成监控工具来监控 Flask 应用。Datadog 提供了一体化的监控和警报平台，可以集中管理日志、性能指标和事件。

步骤 1: 创建 Flask 应用

保持使用之前的 Flask 应用示例。确保 Flask 应用能够生成基本的日志和性能指标。

步骤 2: 集成 Datadog

1. 注册 Datadog 账户：

   • 如果你还没有 Datadog 账户，需要先在 Datadog 官网注册。

2. 获取 Datadog Agent：

   • Datadog 提供了一个特殊的代理程序，用于收集和发送监控数据。
   • 从 Datadog 控制台获取你的 Agent 配置信息。

3. 部署 Datadog Agent：

   • 在与 Flask 应用相同的环境中部署 Datadog Agent。这可以通过 Docker 容器来完成。
   • 设置 Datadog Agent 容器，使其能够收集 Docker 和 Flask 应用的性能指标和日志。

   示例 docker-compose.datadog.yml:

   version: '3'
   services:
     datadog-agent:
       image: datadog/agent:latest
       environment:
         - DD_API_KEY=<你的Datadog API密钥>
         - DD_SITE="datadoghq.com"
         - DD_LOGS_ENABLED=true
         - DD_LOGS_CONFIG_CONTAINER_COLLECT_ALL=true
         - DD_DOGSTATSD_NON_LOCAL_TRAFFIC=true
       volumes:
         - /var/run/docker.sock:/var/run/docker.sock:ro
         - /proc/:/host/proc/:ro
         - /sys/fs/cgroup/:/host/sys/fs/cgroup:ro
       ports:
         - "8125:8125/udp"
   

   运行命令 docker-compose -f docker-compose.datadog.yml up -d 启动 Datadog Agent。

步骤 3: 配置 Flask 应用发送数据到 Datadog

确保 Flask 应用的日志可以被 Datadog Agent 捕获。如果需要，可以通过设置环境变量或配置文件来调整日志级别和格式。

步骤 4: 部署并运行 Flask 应用

使用之前的 Dockerfile 构建 Flask 应用的镜像，并运行它。

步骤 5: 配置 Datadog 仪表板

1. 登录到你的 Datadog 控制台。
2. 创建一个新的仪表板。
3. 添加适合 Flask 应用的监控图表和日志流。
4. 配置任何必要的告警，以便于在性能问题或错误发生时获得通知。

步骤 6: 监控和调优

• 持续监控 Flask 应用的性能和日志。
• 根据收集到的数据调优应用配置，优化性能和资源使用。

通过这个案例，你学会了如何使用 Datadog 这样的集成监控工具来监控 Flask 应用。这种方法提供了一站式的解决方案，方便地对容器化应用进行全面监控，从而确保应用的健康和高效运行。

通过掌握这些监控和日志技能，你将能够保持对容器应用的全面控制，及时响应可能的问题，确保应用的健康和高效运行。

7.2 性能调优与资源限制

让我们探索 Docker 容器的性能调优和资源限制，就像为赛车调校引擎一样，确保它们以最佳状态运行，同时不超过我们设定的极限。

7.2.1 重点基础知识

在容器化的世界中，性能调优和资源限制是确保应用高效运行的关键。了解如何优化容器性能并合理分配资源，就像为高速跑车精确调校，确保它们在赛道上以最佳状态奔跑。

1. 深入理解资源限制:

   • CPU 限制：通过 --cpus 参数指定容器可以使用的 CPU 核心数，例如 --cpus="1.5" 表示容器可以使用最多1.5个 CPU 核心。
   • 内存限制：使用 --memory 或 -m 参数来限制容器的内存使用，例如 -m 512m 限制容器最多使用512 MB内存。

2. 性能监控的进阶应用:

   • 实时性能监控：使用 docker stats 实时监控容器的 CPU 和内存使用情况。
   • 长期性能趋势分析：使用像 Prometheus 这样的工具来收集和分析长期的性能数据，帮助识别和解决长期的性能问题。

3. 网络性能的关键因素:

   • 选择合适的网络模式：例如，host 模式提供最高的网络性能，但牺牲了一些隔离性。
   • 避免端口冲突：合理安排容器端口映射，避免端口冲突和性能瓶颈。

4. 存储驱动的选择和优化:

   • 选择适合的存储驱动：不同的存储驱动（如 aufs、overlay2、btrfs）对 I/O 性能有不同的影响。
   • 考虑使用外部存储解决方案：如云存储服务，或者高性能的本地 SSD 存储，以提高 I/O 性能。

5. 容器启动优化:

   • 减少镜像大小：通过多阶段构建和移除不必要的文件，减少镜像大小，提高容器启动速度。
   • 优化启动命令和脚本：精简容器启动命令和脚本，减少启动时间。

6. 环境特定的优化:

   • 针对特定环境优化：根据容器运行的环境（如云、物理服务器、虚拟机）进行特定的优化。
   • 考虑安全与性能的平衡：在提高性能的同时，不应牺牲安全性。

掌握这些知识和技能可以帮助你更好地管理和优化 Docker 容器的性能，确保应用在不同的运行环境中都能发挥最佳表现。

7.2.2 重点案例：Flask 应用性能调优

在这个案例中，我们将通过设置资源限制和监控来优化 Flask 应用的性能。这就像为你的应用穿上了一件定制的赛车服，确保它在最佳状态下奔跑。

步骤 1: 创建 Flask 应用

首先，创建一个基本的 Flask 应用。在你的工作目录中，创建以下文件：

• app.py:

  # app.py
  from flask import Flask, jsonify
  import time
  
  app = Flask(__name__)
  
  @app.route('/')
  def home():
      # 模拟一些处理时间
      time.sleep(1)
      return jsonify({"message": "Hello from Flask!"})
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  

步骤 2: 编写 Dockerfile

创建 Dockerfile 来构建 Flask 应用的镜像：

FROM python:3.8-slim
WORKDIR /app
COPY . /app/
RUN pip install flask
CMD ["python", "app.py"]

步骤 3: 构建 Flask 应用的镜像

在包含 Dockerfile 的目录中运行以下命令：

docker build -t flask-app-optimized .

步骤 4: 运行 Flask 应用容器（设置资源限制）

使用 Docker 命令启动 Flask 应用容器，并为其设置 CPU 和内存限制：

docker run -d -p 5000:5000 --name flask-app --memory="256m" --cpus="0.5" flask-app-optimized

在这里，我们限制了容器最多只能使用 256MB 内存和半个 CPU 核心。

步骤 5: 监控和调整

使用 docker stats 命令监控 Flask 应用容器的性能：

docker stats flask-app

监控输出将显示容器的 CPU 和内存使用情况。根据这些数据，你可以调整 Flask 应用的资源限制，以找到最佳的性能和资源使用平衡。

步骤 6: 性能测试

使用性能测试工具（如 Apache Bench 或 JMeter）对 Flask 应用进行压力测试，观察应用在不同负载下的表现。

通过这个案例，你将学会如何为 Flask 应用设置合理的资源限制，并监控其性能表现。这有助于你确保应用即使在高负载下也能稳定运行，同时防止它消耗过多的系统资源。

7.2.3 拓展案例 1：网络性能优化

在这个案例中，我们将专注于优化 Flask 应用的网络性能。我们会利用 Docker 的 host 网络模式，以减少网络层的开销，提升网络处理效率。

步骤 1: 创建 Flask 应用

使用之前的 Flask 应用代码。这个简单的应用已足够用来演示网络性能的优化。

• app.py:

  # app.py
  from flask import Flask, jsonify
  
  app = Flask(__name__)
  
  @app.route('/')
  def home():
      return jsonify({"message": "Hello from optimized Flask app!"})
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  

步骤 2: 构建 Flask 应用的镜像

使用相同的 Dockerfile 构建 Flask 应用的 Docker 镜像。

步骤 3: 使用 host 网络模式运行 Flask 容器

运行 Flask 应用容器，并指定使用 host 网络模式。这将移除容器和宿主机之间的网络隔离，提供更高的网络性能。

docker run -d --network host --name flask-app-host flask-app-optimized

注意：使用 host 网络模式可能会降低容器的隔离性，因此应根据具体场景权衡利弊。

步骤 4: 性能测试

1. 使用性能测试工具（如 Apache Bench）对 Flask 应用进行测试。首先，测试标准的桥接网络模式下的性能：

   ab -n 1000 -c 10 http://127.0.0.1:5000/
   

2. 接下来，测试 host 网络模式下的性能：

   ab -n 1000 -c 10 http://<宿主机IP>:5000/
   

3. 比较两种模式下的性能，特别是响应时间和每秒处理的请求数。

步骤 5: 分析和调整

• 分析两种网络模式下的性能测试结果。
• 根据结果调整网络配置，以实现最佳的网络性能。

通过这个案例，你将学会如何调整 Docker 容器的网络设置来优化 Flask 应用的网络性能。这种优化对于提高高流量应用的响应速度和处理能力非常有效。

7.2.4 拓展案例 2：存储性能调优

在这个案例中，我们将探索如何优化 Flask 应用的存储性能。通过选择合适的存储驱动和进行一些配置调整，我们可以提升 Flask 应用处理 I/O 操作的效率。

步骤 1: 创建 Flask 应用

继续使用之前的 Flask 应用结构。为了演示存储性能优化，我们可以添加一些模拟 I/O 操作的代码。

• app.py:

  # app.py
  from flask import Flask, jsonify
  import logging
  import random
  import string
  
  app = Flask(__name__)
  
  @app.route('/write')
  def write_file():
      with open("/data/testfile.txt", "w") as file:
          file.write(''.join(random.choices(string.ascii_uppercase + string.digits, k=1000)))
      return jsonify({"message": "Write operation completed"})
  
  @app.route('/read')
  def read_file():
      with open("/data/testfile.txt", "r") as file:
          content = file.read()
      return jsonify({"content": content})
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  

步骤 2: 构建 Flask 应用的镜像

使用相同的 Dockerfile 构建 Flask 应用的 Docker 镜像。

步骤 3: 配置高性能存储

为了提升存储性能，考虑以下方案：

1. 使用高效的存储驱动，如 overlay2，这是 Docker 的推荐存储驱动。

2. 挂载高性能存储，如果在云环境或有条件的物理环境中，可以将高性能的 SSD 存储作为卷挂载到容器中。

   示例 Docker 命令：

   docker run -d -p 5000:5000 --name flask-app --mount type=bind,source=/path/to/ssd,target=/data flask-app-optimized
   

   替换 /path/to/ssd 为你的 SSD 存储路径。

步骤 4: 测试存储性能

对 Flask 应用的读写操作进行性能测试：

1. 测试写操作：

   curl http://localhost:5000/write
   

2. 测试读操作：

   curl http://localhost:5000/read
   

3. 使用工具（如 iostat 或 iotop）监控容器的 I/O 性能。

步骤 5: 分析和调整

• 分析测试结果，特别注意 I/O 操作的响应时间和吞吐量。
• 根据结果调整存储配置，可能包括更换存储驱动、调整挂载选项等。

通过这个案例，你将学会如何调整 Docker 容器的存储配置，以优化 Flask 应用的 I/O 性能。这对于 I/O 密集型应用来说是一个重要的优化方向，可以显著提高应用的响应速度和处理能力。

通过这些案例，你将学会如何调优 Docker 容器的性能，同时确保资源使用在可接受的范围内。这种平衡对于运行高效且可靠的容器化应用至关重要。

7.3 容器故障排查与恢复

在 Docker 的世界里，容器故障排查和恢复就像是解决一个谜题。了解如何有效地定位和修复问题是确保容器稳定运行的关键。

7.3.1 重点基础知识

在 Docker 的世界里，容器故障排查与恢复是维护应用稳定性的重要技能。像侦探一样分析问题的原因，并找到解决问题的关键线索，是每位 Docker 使用者必备的技能。

1. 理解容器的生命周期:

   • 理解容器的启动、运行、停止和重启流程，以及这些状态在故障排查中的含义。

2. 深入探索日志文件:

   • 日志是故障排查的首要工具。了解如何有效地使用 docker logs 命令来获取容器日志。
   • 掌握日志级别和格式，以便更快地定位问题。

3. 网络问题的诊断方法:

   • 了解 Docker 网络模型和常见的网络问题。
   • 掌握如何使用 docker network 相关命令来诊断网络问题。

4. 存储和卷的问题排查:

   • 确认 Docker 卷的挂载状态和权限设置。
   • 了解 Docker 卷和绑定挂载的不同，及其在故障排查中的影响。

5. 性能监控和瓶颈分析:

   • 使用 docker stats 和其他工具监控容器的资源使用情况。
   • 识别 CPU 和内存使用的异常模式，了解这些模式可能指示的问题。

6. Docker 容器的健康检查:

   • 利用 Docker 的健康检查功能来自动监控容器状态。
   • 理解健康检查配置和结果对故障排查的意义。

7. 恢复策略的制定:

   • 理解何时重启容器，何时重新部署。
   • 了解备份和恢复策略，以防数据丢失。

掌握这些基础知识可以帮助你在容器遇到问题时，迅速反应，准确诊断问题所在，并有效地采取措施恢复服务。这对于维护高可用性和可靠性的 Docker 环境至关重要。

7.3.2 重点案例：排查 Flask 应用故障

在这个案例中，我们将模拟一个 Flask 应用遇到的常见故障，并展示如何一步步排查和解决问题。

步骤 1: 准备 Flask 应用

首先，创建一个 Flask 应用。在你的工作目录中，创建以下文件：

• app.py:

  # app.py
  from flask import Flask, jsonify
  import os
  
  app = Flask(__name__)
  
  @app.route('/')
  def home():
      return jsonify({"message": "Welcome to the Flask app!"})
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  

步骤 2: 构建并运行 Flask 应用容器

使用 Docker 构建 Flask 应用的镜像，并运行容器：

docker build -t flask-app .
docker run -d -p 5000:5000 --name flask-app flask-app

步骤 3: 模拟故障

假设 Flask 应用突然停止响应请求。我们需要排查原因。

步骤 4: 查看容器日志

首先，检查 Flask 应用的日志，看是否有错误信息：

docker logs flask-app

步骤 5: 检查容器状态和配置

如果日志中没有明显错误，检查容器的状态和配置：

docker inspect flask-app

步骤 6: 进入容器进行检查

如果需要更深入地检查，可以进入容器：

docker exec -it flask-app /bin/bash

在容器内部，可以检查网络配置、运行进程、打开的端口等。

步骤 7: 分析和解决

根据收集到的信息，分析可能的故障原因。例如：

• 网络配置错误导致 Flask 应用无法访问。
• Flask 应用内部错误导致服务崩溃。
• 资源限制导致应用性能问题。

根据分析结果采取相应措施，如调整网络配置、修复代码错误或修改资源限制。

步骤 8: 验证修复

修复问题后，重新启动容器并验证 Flask 应用是否恢复正常。

通过这个案例，你可以学会基本的 Docker 容器故障排查流程，这对于维护稳定可靠的容器化应用至关重要。

7.3.3 拓展案例 1：解决网络连接问题

在这个案例中，我们将排查 Flask 应用无法连接到外部数据库的网络连接问题。这是 Docker 容器中常见的问题之一，涉及到容器的网络配置和连接。

步骤 1: 创建 Flask 应用和数据库服务

• 假设 Flask 应用需要连接到一个远程数据库。

• app.py:

  # app.py
  from flask import Flask
  import os
  import MySQLdb
  
  app = Flask(__name__)
  
  @app.route('/')
  def home():
      db_host = os.getenv('DB_HOST', 'localhost')
      try:
          db = MySQLdb.connect(host=db_host, user="user", passwd="password", db="mydb")
          return "Database connection successful"
      except MySQLdb.Error as e:
          return str(e)
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  

步骤 2: 构建 Flask 应用的镜像

使用 Docker 构建 Flask 应用的镜像，并运行容器：

docker build -t flask-app-network-issue .
docker run -d -p 5000:5000 -e DB_HOST=<数据库地址> --name flask-app flask-app-network-issue

步骤 3: 模拟和诊断网络连接问题

• 当 Flask 应用无法连接到数据库时，首先检查容器日志：

  docker logs flask-app
  

• 如果日志中显示连接失败的错误，检查 Flask 应用的环境变量 DB_HOST 是否正确配置。

步骤 4: 检查网络配置

• 使用 docker inspect flask-app 检查 Flask 容器的网络配置。
• 确保容器被分配到正确的网络，并且该网络可以访问数据库服务器。

步骤 5: 容器内部网络诊断

• 进入 Flask 容器：

  docker exec -it flask-app /bin/bash
  

• 在容器内部使用网络诊断工具（如 ping、telnet 或 traceroute）测试与数据库服务器的连接。

步骤 6: 解决网络问题

• 根据诊断结果，可能需要调整 Docker 网络配置，修改容器的网络模式，或者调整宿主机或网络设备的防火墙规则。

步骤 7: 验证修复

• 修复网络问题后，重新启动 Flask 应用容器并验证是否能成功连接到数据库。

通过这个案例，你可以学会如何诊断和解决 Docker 容器的网络连接问题。这种技能对于确保容器化应用的连通性和可靠性至关重要。

7.3.4 拓展案例 2：处理存储相关问题

在这个案例中，我们将处理与 Docker 容器中存储相关的常见问题，如挂载卷、持久化数据和文件权限等。

步骤 1: 创建一个需要持久化数据的 Flask 应用

• 假设我们有一个 Flask 应用需要将上传的文件保存到本地目录中。

• app.py:

  # app.py
  from flask import Flask, request, redirect, url_for
  import os
  
  app = Flask(__name__)
  
  UPLOAD_FOLDER = '/uploads'
  ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif'}
  
  app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
  
  def allowed_file(filename):
      return '.' in filename and \
             filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
  
  @app.route('/', methods=['GET', 'POST'])
  def upload_file():
      if request.method == 'POST':
          if 'file' not in request.files:
              return redirect(request.url)
          file = request.files['file']
          if file.filename == '':
              return redirect(request.url)
          if file and allowed_file(file.filename):
              filename = os.path.join(app.config['UPLOAD_FOLDER'], file.filename)
              file.save(filename)
              return redirect(url_for('upload_file'))
      return '''
      <!doctype html>
      <title>Upload new File</title>
      <h1>Upload new File</h1>
      <form method=post enctype=multipart/form-data>
        <input type=file name=file>
        <input type=submit value=Upload>
      </form>
      '''
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  

步骤 2: 创建一个 Dockerfile 并构建镜像

# Dockerfile
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt

COPY . .

VOLUME /uploads

CMD ["python", "app.py"]

docker build -t flask-app-storage-issue .

步骤 3: 运行容器并上传文件

docker run -d -p 5000:5000 --name flask-app-storage -v $(pwd)/uploads:/uploads flask-app-storage-issue

步骤 4: 上传文件并验证存储功能

通过浏览器或命令行上传文件到 Flask 应用，然后在本地检查 ./uploads 目录，确认文件是否成功保存。

步骤 5: 处理权限问题

如果容器中的应用无法写入挂载的卷，可能是文件权限问题。在 Dockerfile 中添加适当的文件权限设置命令，例如：

RUN chmod -R 777 /uploads

重新构建镜像并重新运行容器，验证文件写入功能是否正常。

通过这个案例，你可以学会如何处理 Docker 容器中与存储相关的常见问题，并确保应用程序能够正确地使用挂载卷进行数据持久化。

通过掌握这些故障排查技能，你将能够快速响应和修复 Docker 容器中的问题，保持应用的稳定和高效运行。