备案控制台
探索云世界
开发者社区 数据库 文章 正文

《Docker 简易速速上手小册》第5章 Docker Compose 与服务编排（2024 最新版）

2024-04-19 40
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云原生数据库 PolarDB MySQL 版，Serverless 5000PCU 100GB
推荐场景：
PolarDB for MySQL 多主集群体验
云数据库 Redis 版，社区版 2GB
推荐场景：
搭建游戏排行榜
简介： 《Docker 简易速速上手小册》第5章 Docker Compose 与服务编排（2024 最新版）

382ad14d55adeb4a09fe99e86dfa123.png

5.1 理解 Docker Compose

进入 Docker Compose 的世界就像开启了一扇通往高效容器管理和编排的大门。让我们一起探索 Docker Compose 的基础，并通过实践加深理解。

5.1.1 重点基础知识

深入理解 Docker Compose 是掌握现代容器化应用部署的关键。Docker Compose 使得管理复杂的多容器应用变得简单。以下是有关 Docker Compose 的更多基础知识，它们将帮助你更有效地使用这个强大的工具。

  1. 版本和兼容性:
  • Docker Compose 文件顶部通常指定一个版本号，例如 version: '3'。这决定了你可以使用哪些特性和语法。
  • 不同的 Docker 和 Compose 版本支持不同的功能。了解你正在使用的版本的特性至关重要。
  1. 服务配置细节:
  • 服务可以通过 build 指令从 Dockerfile 构建，或者直接从已有的镜像启动。
  • 服务配置可以包括环境变量、依赖关系、启动顺序和健康检查。
  1. 网络的高级配置:
  • 可以定义多个网络，并指定服务所连接的网络。这允许创建复杂的网络拓扑结构，实现高级网络隔离和通信策略。
  • 支持网络别名，使得在网络内部服务间通信更灵活。
  1. 卷的高级配置:
  • 支持多种类型的卷配置，包括匿名卷、命名卷和绑定挂载。
  • 可以配置卷的驱动、标签和权限设置，适用于不同的存储需求。
  1. 环境变量和 .env 文件:
  • 在 docker-compose.yml 文件中使用环境变量可以提高配置的灵活性。
  • .env 文件用于定义环境变量，Compose 在启动时会自动加载这些变量。
  1. 扩展和重用配置:
  • Docker Compose 支持服务配置的扩展和重用，这使得维护多个类似但略有不同的应用配置更为简单。
  1. 调试和日志管理:
  • Docker Compose 提供了日志查看和服务调试的工具，帮助你监控和诊断服务的运行状态。

通过掌握这些高级知识，你将能够更加精确地控制你的多容器应用，从而构建更加可靠和高效的 Docker 应用环境。这对于任何希望在生产环境中有效利用 Docker 的人来说都是非常重要的技能。

5.1.2 重点案例：部署 Flask 应用和 Redis

在这个案例中，我们将使用 Docker Compose 来部署一个 Python Flask 应用，并结合使用 Redis 作为后端存储。这个实例将展示如何使用 Docker Compose 管理多容器应用，实现前端应用与后端服务的协作。

步骤 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')
cache = redis.Redis(host=redis_host, port=6379)
@app.route('/')
def home():
    count = cache.incr('hits')
    return f'Hello, Dockerized Flask with Redis! I have been seen {count} times.'
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)
  • requirements.txt:
flask
redis

步骤 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: 创建 Docker Compose 文件

创建 docker-compose.yml 文件来定义 Flask 应用和 Redis 服务：

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    environment:
      - REDIS_HOST=redis
  redis:
    image: "redis:alpine"

在这里，我们定义了两个服务：web 为 Flask 应用，redis 为 Redis 服务。

步骤 4: 使用 Docker Compose 启动应用

在包含 docker-compose.yml 的目录中，运行以下命令来启动应用：

docker-compose up

这个命令会根据 docker-compose.yml 的定义启动 Flask 应用和 Redis 服务。

步骤 5: 访问 Flask 应用

现在，你可以通过访问 http://localhost:5000 来测试 Flask 应用。每次访问页面时，访问次数应该会增加，显示 Flask 应用成功地与 Redis 服务进行了交互。

通过这个案例，你学会了如何使用 Docker Compose 部署一个结合了前端应用和后端服务的多容器应用。这种方法在现代 Web 开发中非常常见，能够提高开发和部署的效率，同时确保了不同服务之间的良好协作和数据共享。

5.1.3 拓展案例 1：多服务协作

在这个案例中，我们将使用 Docker Compose 来配置一个由 Flask 应用、PostgreSQL 数据库和 Celery 后台任务处理器组成的多服务应用。这个例子展示了如何在 Docker Compose 中管理复杂的服务依赖关系和交互。

步骤 1: 创建 Flask 应用

创建 Flask 应用，它将提交任务给 Celery 处理。在工作目录中创建以下文件：

  • app.py:
# app.py
from flask import Flask
from celery import Celery
app = Flask(__name__)
celery = Celery(app.name, broker='pyamqp://guest@rabbitmq//')
@app.route('/process')
def process():
    result = long_running_task.delay()
    return f'Task submitted, id: {result.id}'
@celery.task
def long_running_task():
    # 这里模拟一个长时间运行的任务
    return 'Task completed'
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)
  • requirements.txt:
flask
celery

步骤 2: 创建 Docker Compose 文件

创建 docker-compose.yml 文件，定义 Flask 应用、Celery worker、RabbitMQ 和 PostgreSQL 服务：

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - rabbitmq
      - db
  worker:
    build: .
    command: celery worker --app=app.celery
    depends_on:
      - rabbitmq
  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "15672:15672"
  db:
    image: postgres
    environment:
      POSTGRES_DB: exampledb
      POSTGRES_USER: exampleuser
      POSTGRES_PASSWORD: examplepass

步骤 3: 构建并运行应用

在包含 docker-compose.yml 的目录中，运行以下命令来构建镜像并启动服务：

docker-compose up --build

步骤 4: 访问 Flask 应用

现在，你可以通过访问 http://localhost:5000/process 来测试 Flask 应用和 Celery 任务的交互。你也可以访问 RabbitMQ 管理界面 http://localhost:15672 来查看消息队列的状态。

通过这个案例，你学会了如何在 Docker Compose 环境中配置并管理一个由多个服务组成的应用。这种方法允许各个服务之间的高效协作，同时保持了配置的简洁和可维护性，非常适合复杂的应用场景。

5.1.4 拓展案例 2：使用自定义网络

在这个案例中，我们将展示如何在 Docker Compose 中使用自定义网络来连接多个服务。我们将部署一个 Flask 应用和一个 Redis 服务，并将它们放在同一个网络中以便相互通信。

步骤 1: 创建 Flask 应用

首先，我们需要创建一个简单的 Flask 应用，它将从 Redis 服务获取数据。在你的工作目录中，创建以下文件：

  • app.py:
# app.py
from flask import Flask
import redis
import os
app = Flask(__name__)
redis_host = os.getenv('REDIS_HOST', 'redis')
cache = redis.Redis(host=redis_host, port=6379)
@app.route('/')
def home():
    count = cache.incr('hits')
    return f'Hello from Flask! I have been seen {count} times.'
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)
  • requirements.txt:
flask
redis

步骤 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: 创建 Docker Compose 文件

编写 docker-compose.yml 文件来定义 Flask 应用和 Redis 服务，并创建自定义网络：

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    networks:
      - app-network
  redis:
    image: "redis:alpine"
    networks:
      - app-network
networks:
  app-network:

在这个配置中，我们定义了一个名为 app-network 的自定义网络，并确保了 Flask 应用（web）和 Redis 服务都连接到这个网络。

步骤 4: 使用 Docker Compose 启动服务

运行以下命令来启动所有服务：

docker-compose up

这将会构建 Flask 应用的镜像，并启动 Flask 应用和 Redis 服务。

步骤 5: 测试应用

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

通过这个案例，你学会了如何在 Docker Compose 中使用自定义网络来协调多个服务之间的通信。这种设置提供了更好的网络隔离和管理，有助于创建更加健壮和可扩展的应用架构。

通过这些案例，你将能够深入理解 Docker Compose 的强大功能，学会如何有效地使用它来构建和管理复杂的多容器应用。Docker Compose 不仅提高了开发和部署的效率，还使得整个过程更加可靠和可维护。

5.2 编排多容器应用

编排多容器应用是 Docker Compose 的核心特性，它让管理一组相互关联的容器变得轻而易举。这就像是指挥一场精彩的交响乐，每个乐器就是一个容器，共同演奏出和谐的旋律。

5.2.1 重点基础知识

在 Docker Compose 的世界中，编排多容器应用就像是构建一座精巧的模型城市，每个容器就像是一个独立的建筑，共同构成一个完整的功能体系。以下是关于编排多容器应用的一些关键基础知识。

  1. Compose 文件的编写:
  • docker-compose.yml 是 Docker Compose 的核心，通过该文件可以定义服务（容器）、网络、卷等。
  • Compose 文件使用 YAML 格式编写，支持多种配置选项来精确控制每个组件。
  1. 服务的扩展与副本:
  • Docker Compose 支持服务扩展，即运行服务的多个实例。这在负载均衡和高可用性设计中非常重要。
  • 通过 deploy 配置键和 replicas 子键可以指定服务的副本数量。
  1. 健康检查和重启策略:
  • 在服务定义中，可以指定健康检查来确保容器正常运行。如果健康检查失败，容器可以被自动重启。
  • 重启策略包括 no、always、on-failure 和 unless-stopped。
  1. 环境配置文件:
  • 可以使用 .env 文件或 environment 配置来设置环境变量，这有助于将配置与代码分离。
  1. 数据持久化和备份:
  • 通过配置卷，可以持久化和备份重要数据。这对于数据库和需要持久存储的服务尤为重要。
  1. 日志配置:
  • Compose 允许配置服务的日志选项，这有助于监控和调试应用。
  • 可以定义日志驱动和参数，如日志轮转和文件大小限制。
  1. 使用 Compose 命令:
  • Docker Compose 提供了一系列命令来管理应用的生命周期，如 up、down、logs、exec 等。

通过掌握这些高级知识，你将能够更有效地管理和编排你的多容器 Docker 应用。不论是简单的两容器应用还是复杂的微服务架构，合理的编排都是确保应用顺利运行的关键。

5.2.2 重点案例：部署 Flask 应用和数据库

在这个案例中，我们将使用 Docker Compose 来部署一个 Python Flask 应用，并配合 PostgreSQL 数据库。这个例子将展示如何使用 Docker Compose 管理包含前端服务和后端数据库的应用。

步骤 1: 创建 Flask 应用

创建一个 Flask 应用，它将从 PostgreSQL 数据库读取和写入数据。在你的工作目录中，创建以下文件：

  • app.py:
# app.py
from flask import Flask, jsonify
from flask_sqlalchemy import SQLAlchemy
import os
app = Flask(__name__)
db_uri = os.getenv('DATABASE_URL', 'postgresql://exampleuser:examplepass@db/exampledb')
app.config['SQLALCHEMY_DATABASE_URI'] = db_uri
db = SQLAlchemy(app)
class Message(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    content = db.Column(db.String(255), nullable=False)
@app.route('/')
def home():
    message = Message.query.first()
    content = message.content if message else 'No message found'
    return jsonify({"message": content})
if __name__ == '__main__':
    db.create_all()
    if not Message.query.first():
        db.session.add(Message(content='Hello from Flask!'))
        db.session.commit()
    app.run(debug=True, host='0.0.0.0', port=5000)
  • requirements.txt:
flask
flask_sqlalchemy
psycopg2-binary

步骤 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: 创建 Docker Compose 文件

编写 docker-compose.yml 文件来定义 Flask 应用和 PostgreSQL 服务：

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
    environment:
      - DATABASE_URL=postgresql://exampleuser:examplepass@db/exampledb
  db:
    image: postgres
    environment:
      POSTGRES_DB: exampledb
      POSTGRES_USER: exampleuser
      POSTGRES_PASSWORD: examplepass
    volumes:
      - postgres_data:/var/lib/postgresql/data
volumes:
  postgres_data:

在这里，我们定义了 web 服务为 Flask 应用，db 服务为 PostgreSQL 数据库。同时使用了一个命名卷 postgres_data 来持久化数据库数据。

步骤 4: 使用 Docker Compose 启动服务

运行以下命令来启动所有服务：

docker-compose up

这将会构建 Flask 应用的镜像，并启动 Flask 应用和 PostgreSQL 数据库。

步骤 5: 测试应用

现在，你可以通过访问 http://localhost:5000 来测试 Flask 应用。页面应该显示来自数据库的消息。

通过这个案例，你学会了如何使用 Docker Compose 部署含有前端服务和后端数据库的应用。这种模式在现代 web 开发中非常常见，Docker Compose 使得管理这种多服务应用变得简单和高效。

5.2.3 拓展案例 1：多服务负载均衡

在这个案例中，我们将通过 Docker Compose 部署一个 Flask 应用，并使用 Nginx 作为反向代理来实现负载均衡。这个设置允许我们平衡进入 Flask 应用的请求，提高应用的可用性和响应能力。

步骤 1: 创建 Flask 应用

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

  • app.py:
# app.py
from flask import Flask
import socket
app = Flask(__name__)
@app.route('/')
def home():
    return f'Hello from Flask! Served by {socket.gethostname()}'
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)
  • requirements.txt:
flask

步骤 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: 创建 Nginx 配置

创建 Nginx 的配置文件 nginx.conf：

events {}
http {
    upstream flask {
        least_conn;
        server web1:5000;
        server web2:5000;
    }
    server {
        listen 80;
        location / {
            proxy_pass http://flask;
        }
    }
}

这个配置定义了一个上游 flask，其中包括两个 Flask 服务实例，并使用 least_conn 方法进行负载均衡。

步骤 4: 创建 Docker Compose 文件

编写 docker-compose.yml 文件来定义 Flask 应用、Nginx 服务及其网络：

version: '3'
services:
  web1:
    build: .
    networks:
      - app-network
  web2:
    build: .
    networks:
      - app-network
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - web1
      - web2
    networks:
      - app-network
networks:
  app-network:

在这里，我们定义了两个 Flask 服务实例 web1 和 web2 以及一个 Nginx 服务。

步骤 5: 使用 Docker Compose 启动服务

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

docker-compose up

步骤 6: 测试负载均衡

现在，你可以通过访问 http://localhost 来测试应用。每次刷新页面时，你应该会看到由不同的 Flask 服务实例响应的消息，这表明负载均衡正在正常工作。

通过这个案例，你学会了如何使用 Docker Compose 和 Nginx 来设置多服务应用的负载均衡。这种设置对于分发高流量并提高大规模应用的稳定性和可用性非常重要。

5.2.4 拓展案例 2：使用自定义网络隔离服务

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

步骤 1: 创建两个 Flask 应用

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

  • api_app.py (公共 API 应用):
# api_app.py
from flask import Flask, jsonify
import requests
app = Flask(__name__)
@app.route('/data')
def get_data():
    response = requests.get('http://internal-service:5001/internal-data')
    return jsonify({"data": response.json()})
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)
  • internal_app.py (内部服务应用):
# internal_app.py
from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/internal-data')
def internal_data():
    return jsonify({"internal": "secret data"})
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5001)
  • requirements.txt:
flask
requests

步骤 2: 编写 Dockerfile

为两个 Flask 应用创建同一个 Dockerfile：

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

步骤 3: 创建 Docker Compose 文件

编写 docker-compose.yml 文件来定义两个 Flask 应用并设置网络：

version: '3'
services:
  api-service:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        app: api_app.py
    ports:
      - "5000:5000"
    networks:
      - public-network
  internal-service:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        app: internal_app.py
    networks:
      - internal-network
networks:
  public-network:
  internal-network:

在这里，我们定义了 api-service 和 internal-service，并将它们分别放入不同的网络中。

步骤 4: 使用 Docker Compose 启动服务

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

docker-compose up

步骤 5: 测试服务隔离

现在，你可以通过访问 http://localhost:5000/data 来测试 API 服务是否能够访问内部服务。同时，由于内部服务没有暴露在公共网络上，它不应该直接从外部可访问。

通过这个案例，你学会了如何使用 Docker Compose 中的自定义网络来隔离服务。这种配置确保了服务之间的安全通信，是构建具有严格安全要求的多服务应用的重要技术。

通过这些案例，你将学会如何有效地使用 Docker Compose 来编排多容器应用，确保它们协同工作，提供高效、稳定的服务。这些技能在现代云计算和微服务架构中尤为重要。

5.3 Compose 文件详解

在 Docker Compose 的世界中，docker-compose.yml 文件就像是构建应用的蓝图。它详细定义了服务（服务即容器）、网络、卷等组成部分。深入了解这个文件的结构和选项对于高效地使用 Docker Compose 来部署和管理应用至关重要。

5.3.1 重点基础知识

深入理解 Docker Compose 文件的各个组成部分是掌握 Docker 应用部署的关键。docker-compose.yml 文件中的每一行配置都像是为你的应用编写的精密脚本。以下是更详细的关于 Compose 文件的基础知识。

  1. 服务（Services）的高级配置:
  • command：自定义容器启动后执行的命令。
  • links：链接到其他容器，不推荐使用，建议使用网络。
  • restart：设置重启策略，如 always、on-failure、unless-stopped。
  1. 网络（Networks）的深入理解:
  • 支持定义网络的类型，如 bridge、overlay。
  • 可以设置网络的其他参数，如 driver_opts、ipam 等。
  1. 卷（Volumes）的复杂配置:
  • 支持设置卷的类型，如 volume、bind mount 或 tmpfs。
  • 配置卷的选项，如 readonly、volume-labels。
  1. 构建（Build）的细节:
  • context：指定 Dockerfile 所在的上下文路径。
  • dockerfile：指定使用的 Dockerfile 文件名。
  • args：构建镜像时传递给 Dockerfile 的变量。
  1. 环境配置的策略:
  • env_file：指定一个或多个环境变量文件。
  • environment：直接在 Compose 文件中设置环境变量，可以用于覆盖 env_file 中的变量。
  1. 日志（Logging）的配置:
  • 设置日志驱动和相关的配置选项，如 driver、options 等。
  • 控制日志的输出，以便于监控和调试。
  1. 扩展（Extends）功能:
  • 允许一个服务继承另一个服务的配置。
  • 有助于减少重复配置，特别是在处理多个相似服务时。

通过理解这些高级功能，你将能够更加精确和灵活地控制你的 Docker 应用。Compose 文件不仅仅是容器的配置清单，它还是你的应用在 Docker 环境中的完整蓝图。

5.3.2 重点案例：部署 Flask 应用和数据库

在这个案例中，我们将使用 Docker Compose 来部署一个 Python Flask 应用和一个 PostgreSQL 数据库。这个示例展示了如何将前端 Web 应用与后端数据库结合，演示了 Docker Compose 在管理多容器应用中的效力。

步骤 1: 创建 Flask 应用

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

  • app.py:
# app.py
from flask import Flask, jsonify
from flask_sqlalchemy import SQLAlchemy
import os
app = Flask(__name__)
db_uri = os.getenv('DATABASE_URL', 'postgresql://exampleuser:examplepass@db/exampledb')
app.config['SQLALCHEMY_DATABASE_URI'] = db_uri
db = SQLAlchemy(app)
class Message(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    content = db.Column(db.String(255), nullable=False)
@app.route('/')
def home():
    message = Message.query.first()
    content = message.content if message else 'No message found'
    return jsonify({"message": content})
if __name__ == '__main__':
    db.create_all()
    if not Message.query.first():
        db.session.add(Message(content='Hello from Flask!'))
        db.session.commit()
    app.run(debug=True, host='0.0.0.0', port=5000)
  • requirements.txt:
flask
flask_sqlalchemy
psycopg2-binary

步骤 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: 创建 Docker Compose 文件

编写 docker-compose.yml 文件来定义 Flask 应用和 PostgreSQL 服务：

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
    environment:
      - DATABASE_URL=postgresql://exampleuser:examplepass@db/exampledb
  db:
    image: postgres
    environment:
      POSTGRES_DB: exampledb
      POSTGRES_USER: exampleuser
      POSTGRES_PASSWORD: examplepass
    volumes:
      - postgres_data:/var/lib/postgresql/data
volumes:
  postgres_data:

步骤 4: 使用 Docker Compose 启动服务

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

docker-compose up

这将会构建 Flask 应用的镜像，并启动 Flask 应用和 PostgreSQL 数据库。

步骤 5: 测试应用

现在，你可以通过访问 http://localhost:5000 来测试 Flask 应用。页面应该显示从数据库中检索的消息。

通过这个案例，你学会了如何使用 Docker Compose 来部署一个涉及前端服务和后端数据库的多容器应用。这个案例展示了 Docker Compose 在开发和测试环境中的强大能力，特别是在处理依赖关系复杂的应用时。

5.3.3 拓展案例 1：使用多个 Docker Compose 文件

在这个案例中，我们将探讨如何使用两个 Docker Compose 文件来分别管理开发和生产环境的配置。这种做法可以帮助我们在不同环境中灵活地调整配置，而不必在一个文件中处理所有情况。

步骤 1: 创建 Flask 应用

假设我们已有一个 Flask 应用，与之前案例中相同。我们将使用同样的 app.py 和 requirements.txt 文件。

步骤 2: 编写 Dockerfile

使用之前案例中相同的 Dockerfile 来构建 Flask 应用的镜像。

步骤 3: 创建开发环境的 Docker Compose 文件

创建 docker-compose.yml 文件，专门用于开发环境：

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    environment:
      - FLASK_ENV=development
    volumes:
      - .:/app

在这个配置中，我们将应用代码挂载为卷，以便开发时能够实时更新。

步骤 4: 创建生产环境的 Docker Compose 文件

创建 docker-compose.prod.yml 文件，用于生产环境：

version: '3'
services:
  web:
    build: .
    ports:
      - "80:5000"
    environment:
      - FLASK_ENV=production

在生产环境配置中，我们将 Flask 应用的端口映射到 80 端口，并设置环境变量以指示生产环境。

步骤 5: 使用 Docker Compose 启动服务

  • 在开发环境中，运行以下命令：
docker-compose up
  • 在生产环境中，运行以下命令：
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up
  • 这会先读取 docker-compose.yml 的配置，然后用 docker-compose.prod.yml 中的配置覆盖它。

步骤 6: 测试应用

在开发环境中，你可以访问 http://localhost:5000 来测试应用。在生产环境中，应用将可通过 http://localhost 访问。

通过这个案例，你学会了如何使用多个 Docker Compose 文件来管理不同环境下的配置。这种方法提供了很大的灵活性，使得在开发和生产环境之间切换变得简单而无缝。

5.3.4 拓展案例 2：利用 Compose 实现零停机部署

在这个案例中，我们将使用 Docker Compose 来实现 Flask 应用的零停机部署。零停机部署是一种更新应用而不中断服务的策略，它对于维持高可用性的生产环境非常重要。

步骤 1: 创建 Flask 应用

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

  • app.py:
# app.py
from flask import Flask
from datetime import datetime
app = Flask(__name__)
@app.route('/')
def home():
    return f'Hello from Flask! Updated at {datetime.now()}'
if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)
  • requirements.txt:
flask

步骤 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: 创建 Docker Compose 文件

编写 docker-compose.yml 文件来定义 Flask 应用服务：

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"

步骤 4: 初始部署应用

运行以下命令来部署 Flask 应用：

docker-compose up -d

步骤 5: 更新应用

当应用需要更新时（例如，更改 app.py 中的内容），重新构建镜像并启动新容器：

  1. 重建镜像：
docker-compose build
  1. 使用滚动更新部署新容器：
docker-compose up -d --no-deps --build web
  1. 这个命令会先创建新的 web 服务容器，然后停止并移除旧的容器。

步骤 6: 验证零停机部署

在更新过程中，访问 http://localhost:5000。你应该能够看到应用始终可用，且内容已更新。

通过这个案例，你学会了如何使用 Docker Compose 实现零停机部署，这对于生产环境中的应用更新非常关键。这种方法确保了服务的连续性和可用性，同时允许应用及时更新。

通过这些案例，你将能够充分利用 Docker Compose 的强大功能，从而构建和管理复杂且高效的多容器应用。Compose 文件的深入理解是实现这一目标的关键。

文章标签：
云数据库 Redis 版
云消息队列 MQ
云原生数据库 PolarDB
负载均衡
日志服务
Python
容器
Docker
数据库
NoSQL
关键词：
Docker服务
Docker compose
Docker编排
Docker小册
Docker速速
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore     ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库 ECS 实例和一台目标数据库 RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
江帅帅
目录
相关文章
Yeats_Liao
|
15小时前
|
监控 Linux 开发者
Docker服务systemd配置文件详解
Docker服务systemd配置文件详解
Yeats_Liao
6 0
俄罗斯刺沙蓬
|
2天前
|
Shell 应用服务中间件 nginx
6.Docker Compose
6.Docker Compose
俄罗斯刺沙蓬
9 0
shark-chili
|
4天前
|
网络协议 Java Docker
使用docker编排容器（下）
使用docker编排容器（下）
shark-chili
8 0
shark-chili
|
4天前
|
Java 应用服务中间件 nginx
使用docker编排容器（上）
使用docker编排容器
shark-chili
7 0
三分钟热度的鱼
|
4天前
|
机器学习/深度学习 人工智能 分布式计算
人工智能平台PAI 操作报错合集之在本地构建easyrec docker镜像时遇到了无法连接docker服务如何解决
阿里云人工智能平台PAI (Platform for Artificial Intelligence) 是阿里云推出的一套全面、易用的机器学习和深度学习平台，旨在帮助企业、开发者和数据科学家快速构建、训练、部署和管理人工智能模型。在使用阿里云人工智能平台PAI进行操作时，可能会遇到各种类型的错误。以下列举了一些常见的报错情况及其可能的原因和解决方法。
三分钟热度的鱼
14 1
桃李春风一杯酒
|
5天前
|
存储 监控 安全
【专栏】Docker Compose：轻松实现容器编排的利器
【4月更文挑战第27天】Docker Compose是款轻量级容器编排工具，通过YAML文件统一管理多容器应用。本文分三部分深入讨论其核心概念（服务、网络、卷和配置）、使用方法及最佳实践。从快速入门到高级特性，包括环境隔离、CI/CD集成、资源管理和安全措施。通过案例分析展示如何构建多服务应用，助力高效容器编排与管理。
桃李春风一杯酒
20 2
牵着猫散步的鼠鼠
|
7天前
|
应用服务中间件 网络安全 nginx
快速上手！使用Docker和Nginx部署Web服务的完美指南
快速上手！使用Docker和Nginx部署Web服务的完美指南
牵着猫散步的鼠鼠
25 0
程序员三木
|
8天前
|
NoSQL Redis Docker
[docker] Compose 简介
[docker] Compose 简介
程序员三木
44 1
日出等日落
|
13天前
|
数据可视化 Linux Docker
Linux系统使用Docker部署Dashy导航页服务并实现公网环境访问
Linux系统使用Docker部署Dashy导航页服务并实现公网环境访问
日出等日落
23 4
江帅帅
|
Kubernetes Docker Python
《Docker 简易速速上手小册》第10章 朝着 Docker Swarm 和 Kubernetes 迈进（2024 最新版）
《Docker 简易速速上手小册》第10章 朝着 Docker Swarm 和 Kubernetes 迈进（2024 最新版）
江帅帅
31 0

热门文章

最新文章

  • 1
    LLaMA-Factory 基于docker的大模型多卡分布式微调
  • 2
    Nginx配置详解Docker部署Nginx使用Nginx部署vue前端项目
  • 3
    Docker拉取镜像或者kubectl出现的这个解决方案x509: certificate signed by unknown authority
  • 4
    构建高效自动化运维体系：基于Docker和Kubernetes的最佳实践
  • 5
    【Docker项目实战】使用Docker部署Sun-Panel导航面板
  • 6
    Docker从入门到精通：ubuntu系统安装docker
  • 7
    【Docker项目实战】使用Docker部署PicoShare共享文件平台
  • 8
    【好玩的开源项目】使用Docker部署SyncTV视频同步和共享平台
  • 9
    Docker部署RPG网页小游戏
  • 10
    Docker常用命令以及生命周期管理
  • 1
    如何在Docker容器启动时自动运行脚本
    116
  • 2
    Docker的诞生背景与设计初衷，以及发展前景
    56
  • 3
    docker如何进入镜像其他的SQL
    49
  • 4
    OBCP实践 - OceanBase Docker 体验
    84
  • 5
    深入浅出：基于Docker的微服务部署实践
    52
  • 6
    docker 安装nginx 设置配置文件就启动不了
    102
  • 7
    Apache Flink官方网站提供了关于如何使用Docker进行Flink CDC测试的文档
    147
  • 8
    如何在Linux使用docker部署Swagger Editor并实现无公网IP远程协同编辑API文档
    50
  • 9
    docker desktop 搜索不到images
    259
  • 10
    IDEA集成Docker插件打包服务镜像与运行【附Docker命令汇总】
    177

    • 相关课程

    更多
  • 深入解析Docker容器化技术
  • 基于Docker与Jenkins实现自动化部署
  • Docker 快速入门
  • Docker完全自学手册图文教程
  • AI开发者的Docker实践
  • Docker 入门

    • 相关电子书

    更多
  • 应用 Docker 进行持续交付：用技术改变交付路程
  • 从Docker到容器服务
  • 构建基因数据应用生态系统—— docker in Bio/informatics

    • 相关实验场景

    更多
  • 安装配置Terraform环境
  • 通过容器镜像仓库与容器服务快速部署spring-hello应用
  • 基于ROS快速部署LNMP环境（CentOS 7）
  • Docker Compose部署案例
  • Docker Compose入门
  • 容器镜像的制作2

    • 推荐镜像

    更多
  • docker-ce
  • docker-toolbox
  • alinode
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考