《Docker 简易速速上手小册》第6章 Docker 网络与安全（2024 最新版）

6.1 Docker 网络概念

深入理解 Docker 网络对于确保容器间有效、安全的通信至关重要。就像在繁忙的城市中设计交通网络，正确配置 Docker 网络能确保信息高效流动。

6.1.1 重点基础知识

Docker 网络是容器化架构中的重要组成部分，它不仅连接容器，还定义了容器之间如何交互。理解 Docker 网络的基础知识，就像是学会在复杂的城市交通网络中导航。

1. 网络命名空间（Network Namespace）:

   • Docker 使用网络命名空间来隔离容器的网络堆栈。这意味着每个容器都有自己独立的网络环境，包括 IP 地址、路由表和端口号。

2. 内部和外部通信:

   • 容器可以通过内部网络相互通信，也可以通过配置端口映射与外部世界通信。
   • Docker 提供了内置的 DNS 服务，容器可以通过服务名互相发现。

3. 网络驱动:

   • Docker 支持多种网络驱动，每种驱动适用于不同的用途。
   • 桥接（bridge）：默认驱动，适用于同一主机上的容器通信。
   • 主机（host）：移除容器的网络隔离，直接使用宿主机的网络。
   • 覆盖（overlay）：适用于 Docker Swarm，支持不同 Docker 主机上的容器互联。

4. 网络配置:

   • 可以通过命令行或在 Compose 文件中配置网络。
   • 支持设置 IPAM（IP 地址管理）配置，如子网、网关等。

5. 安全性和隔离:

   • 网络隔离增加了安全性，可以防止未授权的访问。
   • 可以通过防火墙规则和网络策略进一步加强安全性。

6. DNS 和服务发现:

   • Docker 内部的 DNS 服务允许容器通过服务名来互相发现和通信。
   • 这使得容器之间的通信不依赖于静态的 IP 地址。

通过理解这些概念，你将能够更好地管理 Docker 容器的网络连接和通信，确保容器的高效和安全运行。无论是简单的单主机部署还是跨主机的复杂应用，正确的网络配置都是成功的关键。

6.1.2 重点案例：基于 Flask 的微服务

在这个案例中，我们将构建一个基于 Flask 的微服务应用，并使用 Docker 网络来确保其组件可以彼此通信。我们的目标是创建一个 Flask 应用，该应用将与一个后端服务（比如一个 Redis 实例）通信。

步骤 1: 创建 Flask 应用

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

• app.py:

  # app.py
  from flask import Flask
  import redis
  import os
  
  app = Flask(__name__)
  redis_host = os.getenv('REDIS_HOST', 'localhost')
  redis_client = redis.Redis(host=redis_host, port=6379)
  
  @app.route('/')
  def home():
      count = redis_client.incr('hits')
      return f'Hello from Flask! This page has been visited {count} times.'
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

• requirements.txt:

  flask
  redis
  1
  2

步骤 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"]
1
2
3
4
5
6

步骤 3: 使用 Docker 创建网络

在启动容器之前，首先创建一个 Docker 网络：

docker network create flask-network
1

步骤 4: 运行 Redis 容器

运行 Redis 容器，并连接到我们创建的网络：

docker run -d --name redis --network flask-network redis:alpine
1

步骤 5: 运行 Flask 应用容器

构建 Flask 应用的镜像并运行它，同时确保它也连接到同一个网络：

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

步骤 6: 测试应用

现在，你可以通过访问 http://localhost:5000 来测试 Flask 应用。应用应该能够显示页面访问次数，这表明它正在成功地与 Redis 服务通信。

通过这个案例，你学会了如何使用 Docker 网络来构建基于 Flask 的微服务应用。这种方法不仅增加了应用的模块化和可扩展性，还提高了其整体的维护性和可管理性。

6.1.3 拓展案例 1：容器间的直接通信

在这个案例中，我们将展示如何在同一主机网络上运行两个 Flask 应用容器，使它们能够直接通信。这是一个展示 Docker 容器间如何通过主机网络进行通信的实际应用。

步骤 1: 创建两个 Flask 应用

创建两个 Flask 应用，一个作为消息发送者，另一个作为接收者。在你的工作目录中，创建以下文件：

• sender_app.py:

  # sender_app.py
  from flask import Flask, request
  import requests
  
  app = Flask(__name__)
  
  @app.route('/send', methods=['POST'])
  def send():
      message = request.json.get('message', '')
      response = requests.post('http://receiver:5001/receive', json={'message': message})
      return response.text
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

• receiver_app.py:

  # receiver_app.py
  from flask import Flask, request, jsonify
  
  app = Flask(__name__)
  
  @app.route('/receive', methods=['POST'])
  def receive():
      message = request.json.get('message', '')
      print(f"Received message: {message}")
      return jsonify({'status': 'Message received'})
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5001)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

• requirements.txt:

  flask
  requests
  1
  2

步骤 2: 编写 Dockerfile

创建一个通用的 Dockerfile 来构建两个 Flask 应用的镜像：

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

步骤 3: 使用 Docker 运行 Flask 容器

运行两个 Flask 容器，使用 Docker 的主机网络模式：

1. 构建镜像：

   docker build -t flask-app .
   1

2. 运行发送者（sender）应用：

   docker run -d --name sender --network host -v $(pwd)/sender_app.py:/app/app.py flask-app
   1

3. 运行接收者（receiver）应用：

   docker run -d --name receiver --network host -v $(pwd)/receiver_app.py:/app/app.py flask-app
   1

步骤 4: 测试应用通信

使用 curl 或任何 HTTP 客户端向发送者应用发送消息，并观察接收者应用是否收到该消息。

例如，使用 curl 发送 POST 请求：

curl -X POST http://localhost:5000/send -H "Content-Type: application/json" -d '{"message": "Hello from sender"}'
1

检查接收者容器的日志，验证消息是否被正确接收：

docker logs receiver
1

通过这个案例，你可以看到 Docker 容器间如何在同一主机网络下进行直接通信。这种配置对于快速开发和测试内部通信的微服务非常有用。

6.1.4 拓展案例 2：跨主机容器通信

在这个案例中，我们将演示如何在不同主机上部署 Flask 应用和 Redis 服务，并通过 Docker 的覆盖网络实现它们之间的通信。这种配置适用于分布式应用和微服务架构，其中服务分散在多个主机上。

注意：这个案例假设你已经有一个 Docker Swarm 集群的基本了解和设置。Docker Swarm 是 Docker 的原生集群管理工具，支持多主机容器编排。

步骤 1: 创建 Flask 应用

在你的工作目录中，创建 Flask 应用的文件：

• app.py:

  # app.py
  from flask import Flask
  import redis
  import os
  
  app = Flask(__name__)
  redis_host = os.getenv('REDIS_HOST', 'redis')
  redis_client = redis.Redis(host=redis_host, port=6379)
  
  @app.route('/')
  def home():
      count = redis_client.incr('hits')
      return f'Hello from Flask! This page has been visited {count} times.'
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

• requirements.txt:

  flask
  redis
  1
  2

步骤 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"]
1
2
3
4
5
6

步骤 3: 部署 Flask 应用和 Redis 服务

假设你已经初始化了 Docker Swarm 集群，并且有两个或更多的节点可用。

1. 在 Swarm 集群的管理节点上，创建一个覆盖网络：

   docker network create --driver=overlay --attachable my-overlay-net
   1

2. 部署 Flask 应用：

   docker service create \
     --name flask-app \
     --network my-overlay-net \
     --publish published=5000,target=5000 \
     flask-app
   1
   2
   3
   4
   5

3. 部署 Redis 服务：

   docker service create \
     --name redis \
     --network my-overlay-net \
     redis:alpine
   1
   2
   3
   4

步骤 4: 测试跨主机通信

1. 确定 Flask 应用和 Redis 服务的部署状态：

   docker service ls
   1

2. 从任何 Swarm 集群节点访问 Flask 应用：

   curl http://<Swarm_Node_IP>:5000
   1

   应用应该能够正常访问并显示页面访问次数。

通过这个案例，你学会了如何在 Docker Swarm 集群中使用覆盖网络来实现跨主机容器通信。这种能力对于构建大规模、分布式的微服务应用极其重要，使得服务可以在不同的物理机器上灵活部署，同时保持高效的网络通信。

通过这些案例，你将了解 Docker 网络的不同类型及其用例，掌握如何在不同场景下配置和管理 Docker 网络。这是确保 Docker 容器高效、安全运行的关键技能。

6.2 配置与管理网络

掌握 Docker 网络的配置与管理是确保容器应用顺利运行的关键。这就像是在一个复杂的数字世界中布置高速公路和小径，确保信息能够快速且安全地流动。

6.2.1 重点基础知识

深入了解 Docker 网络的配置和管理是确保容器应用顺利运行的关键。掌握这些知识就像是成为了一个数字世界的交通规划师，你需要确保信息的流通既高效又安全。

1. 网络类型的具体应用场景:

   • 桥接网络（bridge）：默认网络类型，适用于单主机内的容器通信。当你需要隔离运行在同一主机上的多个容器时，桥接网络是理想选择。
   • 主机网络（host）：去除容器网络隔离，直接使用宿主机网络。适用于性能敏感的场景，或当容器需要完全访问宿主机网络时。
   • 覆盖网络（overlay）：跨多个 Docker 主机的容器通信，主要用于 Docker Swarm 集群中。当部署跨越多个服务器的服务时，覆盖网络提供了无缝的跨主机通信。

2. 网络配置的高级选项:

   • 子网和网关配置：自定义网络的 IP 地址范围和网关。
   • DNS 配置：设置网络的内置 DNS 服务，用于容器名到 IP 地址的解析。
   • 静态 IP 分配：在需要时为特定容器分配静态 IP 地址。

3. 网络安全和防火墙规则:

   • 设置网络级别的防火墙规则来限制容器间的通信。
   • 利用 Docker 网络策略来加强容器间的隔离和安全性。

4. 网络故障诊断和排错:

   • 使用 docker network inspect 查看网络配置和连接的容器。
   • 利用网络工具（如 ping、traceroute）检查容器间的连通性。

5. 跨主机网络的管理:

   • 在 Docker Swarm 环境中管理覆盖网络。
   • 处理跨主机网络中的路由和服务发现问题。

通过掌握这些高级网络知识，你将能够设计一个既安全又高效的容器网络架构，满足从简单的单机应用到复杂的分布式系统的各种需求。这是每位希望精通 Docker 的开发者和系统管理员必须掌握的技能。

6.2.2 重点案例：配置 Flask 应用的网络

在这个案例中，我们将演示如何配置一个 Flask 应用的网络，使其能够与后端数据库服务（如 MySQL）通信。这个示例将展示如何在 Docker 环境中配置和管理应用的网络连接。

步骤 1: 创建 Flask 应用

首先，创建一个 Flask 应用，它将连接到一个 MySQL 数据库。在你的工作目录中，创建以下文件：

• app.py:

  # app.py
  from flask import Flask, jsonify
  from flask_sqlalchemy import SQLAlchemy
  
  app = Flask(__name__)
  app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://user:password@db/mydatabase'
  db = SQLAlchemy(app)
  
  class User(db.Model):
      id = db.Column(db.Integer, primary_key=True)
      name = db.Column(db.String(80), unique=True, nullable=False)
  
  @app.route('/')
  def index():
      return jsonify({'message': 'Hello from Flask!'})
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18

• requirements.txt:

  flask
  flask_sqlalchemy
  pymysql
  1
  2
  3

步骤 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"]
1
2
3
4
5
6

步骤 3: 创建 Docker 网络

使用 Docker 命令创建一个桥接网络：

docker network create flask-net
1

步骤 4: 运行 MySQL 容器

运行 MySQL 容器，并连接到我们创建的网络：

docker run -d --name db \
  --network flask-net \
  -e MYSQL_ROOT_PASSWORD=root \
  -e MYSQL_DATABASE=mydatabase \
  -e MYSQL_USER=user \
  -e MYSQL_PASSWORD=password \
  mysql:5.7
1
2
3
4
5
6
7

步骤 5: 运行 Flask 应用容器

构建 Flask 应用的镜像并运行它，同时确保它也连接到同一个网络：

docker build -t flask-app .
docker run -d --name flask-app --network flask-net -p 5000:5000 flask-app
1
2

步骤 6: 测试应用

现在，你可以通过访问 http://localhost:5000 来测试 Flask 应用。你应该能够看到 Flask 应用的欢迎消息。

通过这个案例，你学会了如何在 Docker 中为 Flask 应用配置网络，使其能够与后端 MySQL 数据库服务通信。这种网络配置方法对于运行依赖于外部数据库或其他服务的 Web 应用是非常典型且重要的。

6.2.3 拓展案例 1：网络隔离实践

在这个案例中，我们将演示如何使用 Docker 网络隔离来分离前端和后端服务。这种隔离能够提高安全性，确保只有特定的服务能够相互通信。我们将创建两个 Flask 应用，一个作为公共 API，另一个作为内部服务，并确保只有 API 可以访问内部服务。

步骤 1: 创建两个 Flask 应用

在你的工作目录中，创建两个 Flask 应用，一个作为公共 API，另一个作为内部服务。

• api_app.py (公共 API 应用):

  # api_app.py
  from flask import Flask, jsonify
  import requests
  
  app = Flask(__name__)
  
  @app.route('/public')
  def public():
      return jsonify({"message": "Public endpoint"})
  
  @app.route('/access-internal')
  def access_internal():
      try:
          response = requests.get('http://internal-service:5001/internal')
          return response.text
      except requests.exceptions.RequestException as e:
          return str(e)
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20

• internal_app.py (内部服务应用):

  # internal_app.py
  from flask import Flask, jsonify
  
  app = Flask(__name__)
  
  @app.route('/internal')
  def internal():
      return jsonify({"message": "Internal endpoint"})
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5001)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

• requirements.txt:

  flask
  requests
  1
  2

步骤 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", "api_app.py"]
1
2
3
4
5
6

步骤 3: 创建 Docker 网络

创建两个网络，一个用于公共 API，另一个用于内部服务：

docker network create public-net
docker network create internal-net
1
2

步骤 4: 运行 Flask 容器

1. 构建镜像并运行公共 API 应用：

   docker build -t flask-api-app .
   docker run -d --name api-app --network public-net -p 5000:5000 flask-api-app
   1
   2

2. 修改 Dockerfile 以运行内部服务应用，并运行容器：

   # 修改 CMD 指令运行 internal_app.py
   CMD ["python", "internal_app.py"]
   docker build -t flask-internal-app .
   docker run -d --name internal-app --network internal-net flask-internal-app
   1
   2
   3
   4

步骤 5: 测试网络隔离

1. 访问公共 API 端点：

   curl http://localhost:5000/public
   1

   应返回公共端点的消息。

2. 尝试通过公共 API 访问内部服务：

   curl http://localhost:5000/access-internal
   1

   由于网络隔离，这应该失败或返回错误消息。

通过这个案例，你可以看到 Docker 网络如何用于隔离和控制容器间的通信。这种方法在实际生产环境中对于保护敏感的内部服务非常有用，只允许经过授权的服务进行访问。

6.2.4 拓展案例 2：跨主机网络配置

在这个案例中，我们将演示如何在 Docker Swarm 环境中配置跨主机网络，以实现不同主机上的容器间通信。这对于构建大规模、分布式的微服务架构至关重要。

注意：此案例假设你已经配置好了 Docker Swarm 环境，并且有两个或更多的节点可用。

步骤 1: 创建 Flask 应用

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

• app.py:

  # app.py
  from flask import Flask, jsonify
  
  app = Flask(__name__)
  
  @app.route('/')
  def home():
      return jsonify({'message': 'Hello from Flask!'})
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

• requirements.txt:

  flask
  1

步骤 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"]
1
2
3
4
5
6

步骤 3: 创建覆盖网络

在 Docker Swarm 管理节点上，创建一个覆盖网络：

docker network create --driver=overlay --attachable my-overlay-net
1

步骤 4: 部署 Flask 应用

使用 Docker Stack 部署 Flask 应用，并连接到覆盖网络。首先创建 docker-compose.yml 文件：

version: '3'

services:
  web:
    image: flask-app
    networks:
      - my-overlay-net
    ports:
      - "5000:5000"

networks:
  my-overlay-net:
    external: true
1
2
3
4
5
6
7
8
9
10
11
12
13

然后部署应用：

docker stack deploy -c docker-compose.yml myapp
1

步骤 5: 测试跨主机通信

从任何 Swarm 节点访问 Flask 应用：

curl http://<Swarm_Node_IP>:5000
1

应用应该能够正常响应，并显示来自 Flask 的消息。

通过这个案例，你学会了如何在 Docker Swarm 环境中使用覆盖网络配置跨主机通信。这对于运行分布式应用和服务至关重要，使得容器能够跨越物理边界协同工作。

通过这些案例，你将能够更好地理解和实践 Docker 网络的配置与管理，确保容器间的通信既高效又安全。这是构建可靠、可扩展的容器化应用的关键一环。

6.3 Docker 安全最佳实践

在 Docker 的世界中，安全是一个永恒的话题。正确地管理容器安全性对于保护你的应用和数据免受攻击至关重要。让我们一起深入了解 Docker 安全的最佳实践。

6.3.1 重点基础知识

在 Docker 环境中实施安全措施是保护应用和数据不受威胁的关键。正确的安全实践可以帮助你防范各种网络攻击和安全漏洞。让我们深入探讨 Docker 安全的关键要点。

1. 容器运行时安全:

   • 用户权限：避免以 root 用户运行容器。创建并使用具有有限权限的用户。
   • 只读文件系统：当可能时，使用 --read-only 标志运行容器，以使其文件系统为只读。
   • 临时文件系统：使用 --tmpfs 标志为容器提供临时文件存储，以减少对持久存储的依赖。

2. 安全镜像构建:

   • 精简基础镜像：使用精简的基础镜像，如 Alpine Linux，以减少潜在的安全漏洞。
   • 多阶段构建：使用多阶段构建过程来减少最终镜像中不必要的文件和依赖。

3. 网络安全策略:

   • 最小化端口暴露：只暴露必要的端口，避免不必要的端口暴露。
   • 隔离网络：在必要时，创建隔离的 Docker 网络来限制容器间的通信。

4. 安全存储敏感数据:

   • 避免硬编码敏感信息：不要在 Dockerfile 或镜像中硬编码敏感信息。
   • 使用 Docker Secret 或 Volume：对于敏感数据，使用 Docker Secret 或挂载卷来安全存储。

5. 日志和审计:

   • 集中日志管理：配置集中日志管理，如 ELK Stack 或 Fluentd，以监控和分析容器活动。
   • 审计和合规：定期进行安全审计，确保遵守相关的安全合规标准。

6. 定期更新和补丁:

   • 及时更新 Docker 和容器镜像：定期更新 Docker 引擎和容器镜像以获取最新的安全补丁。

通过遵循这些最佳实践，你可以显著提升 Docker 环境的安全性，防止潜在的安全威胁，确保应用和数据的安全。这是每个使用 Docker 的组织和个人都应该关注的重要议题。

6.3.2 重点案例：保护 Flask 应用

在这个案例中，我们将通过实施 Docker 安全最佳实践来部署并保护一个 Flask 应用。这个示例将展示如何在实际环境中增强容器应用的安全性。

步骤 1: 创建 Flask 应用

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

• app.py:

  # app.py
  from flask import Flask
  
  app = Flask(__name__)
  
  @app.route('/')
  def home():
      return "Welcome to the secure Flask app!"
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

• requirements.txt:

  flask
  1

步骤 2: 编写 Dockerfile

为了提高安全性，我们将在 Dockerfile 中使用非 root 用户来运行 Flask 应用：

FROM python:3.8-slim

# 创建一个新用户 "appuser"
RUN useradd -m appuser

# 切换到该用户
USER appuser

WORKDIR /app
COPY requirements.txt /app/
RUN pip install --no-cache-dir -r requirements.txt
COPY . /app/

# 指定运行 Flask 应用的非特权端口
CMD ["python", "app.py"]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

步骤 3: 构建并运行 Flask 容器

1. 构建 Flask 应用的镜像：

   docker build -t secure-flask-app .
   1

2. 运行 Flask 应用容器：

   docker run -d -p 5000:5000 --name flask-app secure-flask-app
   1

   在这里，我们没有使用 root 用户运行容器，且应用在容器内部监听非特权端口（5000）。

步骤 4: 测试 Flask 应用

现在，你可以通过访问 http://localhost:5000 来测试 Flask 应用。应用应该能够正常响应，并显示安全的欢迎信息。

通过这个案例，你学会了如何在 Docker 环境中部署一个安全的 Flask 应用。这包括使用非 root 用户运行应用，最小化容器中的软件包，并且限制容器的网络访问权限。这些措施共同作用，提高了 Flask 应用的安全性，使其更加适合生产环境部署。

6.3.3 拓展案例 1：使用 Docker Secret 管理敏感数据

在这个案例中，我们将使用 Docker Secret 来安全地管理 Flask 应用的敏感数据。Docker Secret 是一种安全地管理敏感数据（如密码、私钥、证书等）的方法，尤其适用于 Docker Swarm 环境。

注意：Docker Secret 需要在 Docker Swarm 模式下运行。

步骤 1: 设置 Docker Swarm

如果你的 Docker 环境尚未初始化为 Swarm，可以通过以下命令进行初始化：

docker swarm init
1

步骤 2: 创建 Flask 应用

创建 Flask 应用，与之前的例子类似，但这次我们将从环境变量中读取敏感数据。

• app.py:

  # app.py
  from flask import Flask
  import os
  
  app = Flask(__name__)
  secret_key = os.getenv('SECRET_KEY', 'default-secret')
  
  @app.route('/')
  def home():
      return f"Secret key is: {secret_key}"
  
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

• requirements.txt:

  flask
  1

步骤 3: 创建 Docker Secret

创建一个 Docker Secret 来存储 Flask 应用的敏感数据：

echo "my-super-secret-key" | docker secret create my_flask_secret -
1

步骤 4: 编写 Docker Compose 文件

为了在 Swarm 中部署 Flask 应用，创建一个 docker-compose.yml 文件：

version: '3.7'

services:
  web:
    image: secure-flask-app
    ports:
      - "5000:5000"
    secrets:
      - my_flask_secret
    environment:
      - SECRET_KEY=/run/secrets/my_flask_secret

secrets:
  my_flask_secret:
    external: true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

和前面步骤类似，构建 Flask 应用的 Docker 镜像。

步骤 6: 部署应用

使用 Docker Stack 部署 Flask 应用到 Swarm：

docker stack deploy -c docker-compose.yml myapp
1

步骤 7: 测试应用

访问 http://localhost:5000，应用应该能够显示出从 Docker Secret 读取的敏感数据。

通过这个案例，你学会了如何在 Docker Swarm 环境中使用 Docker Secret 来安全地管理 Flask 应用的敏感数据。这种方法提供了一种安全、可靠的方式来处理敏感信息，非常适合用于生产环境中的应用部署。

6.3.4 拓展案例 2：实施容器安全扫描和监控

在这个案例中，我们将重点放在对 Docker 容器进行安全扫描和监控，以确保 Flask 应用的安全性。这个过程包括使用工具来识别潜在的安全漏洞，以及设置监控系统来跟踪容器的运行状态。

步骤 1: 准备 Flask 应用

使用前面案例中的 Flask 应用 app.py 和相应的 Dockerfile。

步骤 2: 安全扫描容器

1. 使用 Clair:

   • Clair 是一个流行的开源项目，用于静态分析 Docker 容器的安全漏洞。
   • 可以使用 Clair CLI 工具，如 clair-scanner, 对 Flask 应用的 Docker 镜像进行扫描。

   # 示例命令，实际操作可能需要更多配置
   clair-scanner --ip <你的机器IP> secure-flask-app:latest
   1
   2

2. 使用其他工具:

   • 除了 Clair，还有其他工具和服务如 Anchore Engine、Docker Bench for Security，也可以用于扫描安全漏洞。

步骤 3: 设置监控和日志系统

1. 使用 Prometheus 和 Grafana:

   • Prometheus 是一个开源监控解决方案，可以收集和存储实时指标数据。
   • Grafana 可以用来为 Prometheus 数据创建可视化仪表板。

   # docker-compose.monitoring.yml
   version: '3'
   services:
     prometheus:
       image: prom/prometheus
       ports:
         - 9090:9090
   
     grafana:
       image: grafana/grafana
       ports:
         - 3000:3000
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12

   使用 docker-compose -f docker-compose.monitoring.yml up 运行监控服务。

2. 配置日志记录:

   • 配置 Flask 应用的日志记录，以便将日志数据发送到集中的日志系统，如 ELK Stack 或 Fluentd。

步骤 4: 测试和验证

1. 通过访问 Prometheus 和 Grafana 的 UI（通常是 http://localhost:9090 和 http://localhost:3000），确保监控系统正常运行。
2. 检查 Flask 应用的日志，确保它们被正确记录并发送到日志系统。
3. 定期检查 Clair 或其他安全扫描工具的输出，关注并修复任何识别出的安全漏洞。

通过实施这些步骤，你将能够建立起一个全面的安全策略，不仅能发现并修复潜在的安全漏洞，还能实时监控应用的运行状态，及时发现并响应异常情况。这对于维护任何生产级的 Docker 应用都是至关重要的。

通过这些案例，你将学会如何在日常操作中实施 Docker 的安全最佳实践，确保你的容器环境既安全又可靠。这是每位负责容器化应用的开发者和管理员都必须掌握的技能。