使用Docker Compose部署和管理AI服务

最新推荐文章于 2025-09-25 15:29:07 发布
原创 最新推荐文章于 2025-09-25 15:29:07 发布 · 1.1k 阅读 · 22 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#docker #人工智能 #容器 #Docker Compose # #AI应用 # 容器化

部署运行你感兴趣的模型镜像

摘要

本文将详细介绍如何使用Docker Compose部署和管理一个完整的AI应用系统。我们将从系统的整体架构设计入手，逐步深入到各个服务的配置、部署以及优化。通过实践示例，展示如何在Docker环境中高效地运行AI应用，包括API服务、Web前端、数据库、缓存服务以及多种向量数据库。文章最后将总结关键点，并提供实践建议和扩展阅读资源。本文面向中国开发者，特别是AI应用开发者，内容包括完整的代码示例、架构图、流程图、思维导图、甘特图和饼图等，以增强可读性和实用性。

正文

1. 系统架构设计

在构建AI应用时，系统架构的设计至关重要。一个好的架构可以提高系统的可扩展性、可维护性和性能。以下是我们的系统架构设计：
用户
Web前端
API服务
数据库
PostgreSQL
缓存服务
Redis
向量数据库
Weaviate/Qdrant/Milvus
AI模型服务
管理员
监控系统
开发者
日志系统
1.1 架构组件说明

我们的AI应用系统由以下核心组件构成：

  1. Web前端：提供用户界面，与用户进行交互
  2. API服务：处理业务逻辑，协调各个后端服务
  3. 数据库：存储结构化数据，如用户信息、配置等
  4. 缓存服务：提高系统响应速度，减轻数据库压力
  5. 向量数据库：存储和检索高维向量数据，支持AI检索功能
  6. AI模型服务：提供AI模型推理能力
  7. 监控系统：监控系统性能和健康状态
  8. 日志系统：记录系统运行日志，便于问题排查
1.2 技术选型
AI应用系统
后端技术栈
前端技术栈
基础设施
Python/FastAPI
PostgreSQL
Redis
Weaviate
React/Vue
HTML/CSS/JS
Docker
Docker Compose
Nginx

2. 环境准备

在开始部署之前，确保您的开发环境中已经安装了以下工具：

2.1 安装Docker

Docker是容器化平台的基础，我们需要先安装Docker：

# Ubuntu/Debian系统安装Docker
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

# CentOS/RHEL系统安装Docker
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum install docker-ce docker-ce-cli containerd.io

# 启动Docker服务
sudo systemctl start docker
sudo systemctl enable docker
2.2 安装Docker Compose

Docker Compose是用于定义和运行多容器Docker应用程序的工具：

# 下载Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 添加执行权限
sudo chmod +x /usr/local/bin/docker-compose

# 验证安装
docker-compose --version
2.3 安装Python环境

为了编写和测试相关代码，我们需要Python环境：

# Ubuntu/Debian系统安装Python
sudo apt-get install python3 python3-pip

# CentOS/RHEL系统安装Python
sudo yum install python3 python3-pip

# 安装必要的Python包
pip3 install docker-compose requests python-dotenv

3. Docker Compose文件详解

docker-compose.yaml文件是Docker Compose的核心配置文件，它定义了服务、网络和卷的配置。以下是我们AI应用系统的完整配置：

3.1 基础配置
version: '3.8'

# 定义服务间共享的环境变量
x-shared-env: &shared-api-worker-env
  # 数据库配置
  DB_USERNAME: ${POSTGRES_USER:-postgres}
  DB_PASSWORD: ${POSTGRES_PASSWORD:-difyai123456}
  DB_HOST: db
  DB_PORT: 5432
  DB_DATABASE: ${POSTGRES_DB:-dify}
  
  # Redis配置
  REDIS_HOST: redis
  REDIS_PORT: 6379
  REDIS_USERNAME: 
  REDIS_PASSWORD: ${REDIS_PASSWORD:-difyai123456}
  REDIS_USE_SSL: 'false'
  
  # 向量数据库配置
  VECTOR_STORE: ${VECTOR_STORE:-weaviate}
  WEAVIATE_API_KEY: ${WEAVIATE_API_KEY:-WVF5YThaHlkYwhGUSmCRgsX3tD5ngdN8pkih}
  WEAVIATE_HOST: http://weaviate:8080
  
  # API密钥配置
  SECRET_KEY: ${SECRET_KEY:-sk-abc123}
  WEB_API_KEY: ${WEB_API_KEY:-wk-abc123}
  
  # 文件存储配置
  STORAGE_TYPE: ${STORAGE_TYPE:-local}
  S3_BUCKET_NAME: ${S3_BUCKET_NAME:-dify}
  
  # 其他配置
  APP_URL: ${APP_URL:-http://localhost:3000}
  CONSOLE_URL: ${CONSOLE_URL:-http://localhost:3000}
  CONSOLE_WEB_SERVER_PORT: 3000
3.2 API服务配置

API服务是AI应用的核心，负责处理业务逻辑：

services:
  api:
    image: langgenius/dify-api:1.7.1
    restart: always
    environment:
      <<: *shared-api-worker-env
      MODE: api
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    volumes:
      - ./volumes/app/storage:/app/api/storage
    networks:
      - ssrf_proxy_network
      - default
    deploy:
      resources:
        limits:
          memory: 512M  # 设置内存限制为 512MB
3.3 数据库服务配置

数据库是AI应用的核心组件之一，我们使用PostgreSQL作为数据库：

  db:
    image: postgres:15-alpine
    restart: always
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: ${POSTGRES_USER:-postgres}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-difyai123456}
      POSTGRES_DB: ${POSTGRES_DB:-dify}
      PGDATA: ${PGDATA:-/var/lib/postgresql/data/pgdata}
    command: >
      postgres -c 'max_connections=${POSTGRES_MAX_CONNECTIONS:-100}'
                 -c 'shared_buffers=${POSTGRES_SHARED_BUFFERS:-128MB}'
                 -c 'work_mem=${POSTGRES_WORK_MEM:-4MB}'
                 -c 'maintenance_work_mem=${POSTGRES_MAINTENANCE_WORK_MEM:-64MB}'
                 -c 'effective_cache_size=${POSTGRES_EFFECTIVE_CACHE_SIZE:-4096MB}'
    volumes:
      - ./volumes/db/data:/var/lib/postgresql/data
    healthcheck:
      test: [ 'CMD', 'pg_isready', '-h', 'db', '-U', '${PGUSER:-postgres}', '-d', '${POSTGRES_DB:-dify}' ]
      interval: 1s
      timeout: 3s
      retries: 60
3.4 缓存服务配置

缓存服务可以提高系统的性能，我们使用Redis作为缓存服务：

  redis:
    image: redis:6-alpine
    restart: always
    ports:
      - "6380:6379"
    environment:
      REDISCLI_AUTH: ${REDIS_PASSWORD:-difyai123456}
    volumes:
      - ./volumes/redis/data:/data
    command: redis-server --requirepass ${REDIS_PASSWORD:-difyai123456}
    healthcheck:
      test: [ 'CMD', 'redis-cli', 'ping' ]
3.5 向量数据库配置

向量数据库用于存储和检索高维向量数据，我们支持多种向量数据库：

  weaviate:
    image: semitechnologies/weaviate:1.19.0
    profiles:
      - ''
      - weaviate
    restart: always
    volumes:
      - ./volumes/weaviate:/var/lib/weaviate
    environment:
      PERSISTENCE_DATA_PATH: ${WEAVIATE_PERSISTENCE_DATA_PATH:-/var/lib/weaviate}
      QUERY_DEFAULTS_LIMIT: ${WEAVIATE_QUERY_DEFAULTS_LIMIT:-25}
      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: ${WEAVIATE_AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED:-false}
      DEFAULT_VECTORIZER_MODULE: ${WEAVIATE_DEFAULT_VECTORIZER_MODULE:-none}
      CLUSTER_HOSTNAME: ${WEAVIATE_CLUSTER_HOSTNAME:-node1}
      AUTHENTICATION_APIKEY_ENABLED: ${WEAVIATE_AUTHENTICATION_APIKEY_ENABLED:-true}
      AUTHENTICATION_APIKEY_ALLOWED_KEYS: ${WEAVIATE_AUTHENTICATION_APIKEY_ALLOWED_KEYS:-WVF5YThaHlkYwhGUSmCRgsX3tD5ngdN8pkih}
      AUTHENTICATION_APIKEY_USERS: ${WEAVIATE_AUTHENTICATION_APIKEY_USERS:-hello@dify.ai}
      AUTHORIZATION_ADMINLIST_ENABLED: ${WEAVIATE_AUTHORIZATION_ADMINLIST_ENABLED:-true}
      AUTHORIZATION_ADMINLIST_USERS: ${WEAVIATE_AUTHORIZATION_ADMINLIST_USERS:-hello@dify.ai}
3.6 Web前端服务配置

Web前端服务提供用户界面：

  web:
    image: langgenius/dify-web:1.7.1
    restart: always
    environment:
      CONSOLE_URL: ${CONSOLE_URL:-http://localhost:3000}
      APP_URL: ${APP_URL:-http://localhost:3000}
      NEXT_PUBLIC_API_PREFIX: ${NEXT_PUBLIC_API_PREFIX:-/api}
      NEXT_PUBLIC_LANG: ${NEXT_PUBLIC_LANG:-zh-Hans}
    volumes:
      - ./volumes/web/nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - api
    networks:
      - default
3.7 网络和存储卷配置
networks:
  ssrf_proxy_network:
    driver: bridge
    internal: true
  milvus:
    driver: bridge
  opensearch-net:
    driver: bridge
    internal: true

volumes:
  oradata:
  dify_es01_data:

4. 环境变量配置

创建.env文件来管理环境变量：

# 数据库配置
POSTGRES_USER=postgres
POSTGRES_PASSWORD=difyai123456
POSTGRES_DB=dify
POSTGRES_MAX_CONNECTIONS=100
POSTGRES_SHARED_BUFFERS=128MB
POSTGRES_WORK_MEM=4MB
POSTGRES_MAINTENANCE_WORK_MEM=64MB
POSTGRES_EFFECTIVE_CACHE_SIZE=4096MB

# Redis配置
REDIS_PASSWORD=difyai123456

# 向量数据库配置
VECTOR_STORE=weaviate
WEAVIATE_API_KEY=WVF5YThaHlkYwhGUSmCRgsX3tD5ngdN8pkih

# API密钥配置
SECRET_KEY=sk-abc123
WEB_API_KEY=wk-abc123

# 文件存储配置
STORAGE_TYPE=local
S3_BUCKET_NAME=dify

# 应用URL配置
APP_URL=http://localhost:3000
CONSOLE_URL=http://localhost:3000

5. 实践案例

以下是一个实际的应用场景，展示如何使用Docker Compose部署一个完整的AI应用系统。

5.1 场景描述

假设我们要部署一个智能客服系统，该系统包括以下组件：

  • API服务：处理用户请求和业务逻辑
  • Web前端：提供用户界面
  • 数据库：存储用户数据和业务数据
  • 缓存服务：提高系统性能
  • 向量数据库：存储和检索向量数据
5.2 部署步骤
步骤1：创建项目目录结构
# 创建项目目录
mkdir dify-ai-system
cd dify-ai-system

# 创建必要的子目录
mkdir -p volumes/{app/storage,db/data,redis/data,weaviate,web}
步骤2：创建Docker Compose文件

创建docker-compose.yml文件，内容如前所述。

步骤3：创建环境变量文件

创建.env文件，内容如前所述。

步骤4：创建Web配置文件

创建volumes/web/nginx.conf文件：

events {
    worker_connections 1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;
    error_log   /var/log/nginx/error.log;

    sendfile        on;
    keepalive_timeout  65;

    server {
        listen       80;
        server_name  localhost;

        location / {
            root   /usr/share/nginx/html;
            index  index.html index.htm;
            try_files $uri $uri/ /index.html;
        }

        location /api/ {
            proxy_pass http://api:5001/;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   /usr/share/nginx/html;
        }
    }
}
步骤5：启动服务
# 启动所有服务
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看服务日志
docker-compose logs -f
5.3 Python管理脚本

创建一个Python脚本来管理Docker Compose服务：

# -*- coding: utf-8 -*-
"""
Docker Compose AI服务管理脚本
该脚本提供了对AI应用系统的管理功能
"""

import os
import sys
import time
import subprocess
import logging
from typing import List, Optional

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class DockerComposeManager:
    """Docker Compose服务管理器"""
    
    def __init__(self, compose_file: str = "docker-compose.yml", env_file: str = ".env"):
        """
        初始化管理器
        
        Args:
            compose_file (str): Docker Compose文件路径
            env_file (str): 环境变量文件路径
        """
        self.compose_file = compose_file
        self.env_file = env_file
        self.project_name = "dify-ai-system"
        
        # 检查Docker Compose是否可用
        if not self._check_docker_compose():
            raise RuntimeError("Docker Compose不可用，请先安装Docker Compose")
    
    def _check_docker_compose(self) -> bool:
        """
        检查Docker Compose是否可用
        
        Returns:
            bool: 是否可用
        """
        try:
            result = subprocess.run(
                ["docker-compose", "--version"],
                capture_output=True,
                text=True,
                check=True
            )
            logger.info(f"Docker Compose版本: {result.stdout.strip()}")
            return True
        except (subprocess.CalledProcessError, FileNotFoundError):
            logger.error("Docker Compose未安装或不可用")
            return False
    
    def start_services(self, services: Optional[List[str]] = None) -> bool:
        """
        启动服务
        
        Args:
            services (Optional[List[str]]): 要启动的服务列表，None表示启动所有服务
            
        Returns:
            bool: 是否成功
        """
        try:
            cmd = ["docker-compose", "-f", self.compose_file]
            if self.project_name:
                cmd.extend(["-p", self.project_name])
            cmd.append("up")
            cmd.append("-d")
            
            if services:
                cmd.extend(services)
            
            logger.info(f"启动服务: {' '.join(cmd)}")
            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
            logger.info("服务启动成功")
            return True
            
        except subprocess.CalledProcessError as e:
            logger.error(f"启动服务失败: {e.stderr}")
            return False
        except Exception as e:
            logger.error(f"启动服务时发生未知错误: {e}")
            return False
    
    def stop_services(self, services: Optional[List[str]] = None) -> bool:
        """
        停止服务
        
        Args:
            services (Optional[List[str]]): 要停止的服务列表，None表示停止所有服务
            
        Returns:
            bool: 是否成功
        """
        try:
            cmd = ["docker-compose", "-f", self.compose_file]
            if self.project_name:
                cmd.extend(["-p", self.project_name])
            cmd.append("down")
            
            if services:
                cmd.extend(services)
            
            logger.info(f"停止服务: {' '.join(cmd)}")
            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
            logger.info("服务停止成功")
            return True
            
        except subprocess.CalledProcessError as e:
            logger.error(f"停止服务失败: {e.stderr}")
            return False
        except Exception as e:
            logger.error(f"停止服务时发生未知错误: {e}")
            return False
    
    def restart_services(self, services: Optional[List[str]] = None) -> bool:
        """
        重启服务
        
        Args:
            services (Optional[List[str]]): 要重启的服务列表，None表示重启所有服务
            
        Returns:
            bool: 是否成功
        """
        try:
            # 先停止服务
            if not self.stop_services(services):
                return False
            
            # 等待一段时间
            time.sleep(2)
            
            # 再启动服务
            return self.start_services(services)
            
        except Exception as e:
            logger.error(f"重启服务时发生错误: {e}")
            return False
    
    def get_service_status(self) -> Optional[str]:
        """
        获取服务状态
        
        Returns:
            Optional[str]: 服务状态信息
        """
        try:
            cmd = ["docker-compose", "-f", self.compose_file]
            if self.project_name:
                cmd.extend(["-p", self.project_name])
            cmd.append("ps")
            
            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
            return result.stdout
            
        except subprocess.CalledProcessError as e:
            logger.error(f"获取服务状态失败: {e.stderr}")
            return None
        except Exception as e:
            logger.error(f"获取服务状态时发生未知错误: {e}")
            return None
    
    def view_logs(self, service: Optional[str] = None, follow: bool = False) -> Optional[str]:
        """
        查看服务日志
        
        Args:
            service (Optional[str]): 服务名称
            follow (bool): 是否持续跟踪日志
            
        Returns:
            Optional[str]: 日志内容
        """
        try:
            cmd = ["docker-compose", "-f", self.compose_file]
            if self.project_name:
                cmd.extend(["-p", self.project_name])
            cmd.append("logs")
            
            if follow:
                cmd.append("-f")
            
            if service:
                cmd.append(service)
            
            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
            return result.stdout
            
        except subprocess.CalledProcessError as e:
            logger.error(f"查看日志失败: {e.stderr}")
            return None
        except Exception as e:
            logger.error(f"查看日志时发生未知错误: {e}")
            return None
    
    def execute_command(self, service: str, command: List[str]) -> Optional[str]:
        """
        在服务容器中执行命令
        
        Args:
            service (str): 服务名称
            command (List[str]): 要执行的命令
            
        Returns:
            Optional[str]: 命令执行结果
        """
        try:
            cmd = ["docker-compose", "-f", self.compose_file]
            if self.project_name:
                cmd.extend(["-p", self.project_name])
            cmd.append("exec")
            cmd.append(service)
            cmd.extend(command)
            
            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
            return result.stdout
            
        except subprocess.CalledProcessError as e:
            logger.error(f"执行命令失败: {e.stderr}")
            return None
        except Exception as e:
            logger.error(f"执行命令时发生未知错误: {e}")
            return None

# 使用示例
if __name__ == "__main__":
    try:
        # 创建管理器实例
        manager = DockerComposeManager()
        
        # 获取服务状态
        print("=== 当前服务状态 ===")
        status = manager.get_service_status()
        if status:
            print(status)
        
        # 启动所有服务
        print("\n=== 启动所有服务 ===")
        if manager.start_services():
            print("所有服务启动成功")
        else:
            print("服务启动失败")
        
        # 等待服务启动
        time.sleep(10)
        
        # 查看API服务日志
        print("\n=== API服务日志 ===")
        logs = manager.view_logs("api", follow=False)
        if logs:
            print(logs[:1000])  # 只显示前1000个字符
        
        # 在数据库容器中执行命令
        print("\n=== 数据库连接测试 ===")
        db_result = manager.execute_command("db", ["pg_isready", "-U", "postgres"])
        if db_result is not None:
            print("数据库连接测试结果:", db_result.strip())
        else:
            print("数据库连接测试失败")
            
    except Exception as e:
        print(f"程序执行出错: {e}")

6. 监控和日志管理

6.1 资源监控

创建一个资源监控脚本：

# -*- coding: utf-8 -*-
"""
Docker容器资源监控脚本
该脚本用于监控Docker容器的资源使用情况
"""

import subprocess
import json
import time
import logging
from typing import Dict, List, Optional

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class DockerResourceMonitor:
    """Docker资源监控器"""
    
    def __init__(self):
        """初始化监控器"""
        self.containers = []
    
    def get_container_stats(self, container_name: Optional[str] = None) -> Optional[List[Dict]]:
        """
        获取容器资源统计信息
        
        Args:
            container_name (Optional[str]): 容器名称，None表示获取所有容器
            
        Returns:
            Optional[List[Dict]]: 容器统计信息列表
        """
        try:
            cmd = ["docker", "stats", "--no-stream", "--format", "json"]
            if container_name:
                cmd.append(container_name)
            else:
                cmd.append("--all")
            
            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
            
            # 解析JSON输出
            stats_list = []
            for line in result.stdout.strip().split('\n'):
                if line:
                    stats = json.loads(line)
                    stats_list.append(stats)
            
            return stats_list
            
        except subprocess.CalledProcessError as e:
            logger.error(f"获取容器统计信息失败: {e.stderr}")
            return None
        except json.JSONDecodeError as e:
            logger.error(f"解析JSON数据失败: {e}")
            return None
        except Exception as e:
            logger.error(f"获取容器统计信息时发生未知错误: {e}")
            return None
    
    def format_stats(self, stats_list: List[Dict]) -> str:
        """
        格式化统计信息
        
        Args:
            stats_list (List[Dict]): 统计信息列表
            
        Returns:
            str: 格式化后的统计信息
        """
        if not stats_list:
            return "没有容器统计信息"
        
        output = []
        output.append(f"{'容器名称':<20} {'CPU使用率':<12} {'内存使用':<20} {'网络I/O':<25} {'块I/O':<25}")
        output.append("-" * 100)
        
        for stats in stats_list:
            name = stats.get('Name', 'N/A')[:19]
            cpu = stats.get('CPUPerc', 'N/A')
            mem = f"{stats.get('MemUsage', 'N/A')} / {stats.get('MemLimit', 'N/A')}"
            net = f"接收:{stats.get('NetIO_Rx', 'N/A')} 发送:{stats.get('NetIO_Tx', 'N/A')}"
            block = f"读取:{stats.get('BlockIO_Read', 'N/A')} 写入:{stats.get('BlockIO_Write', 'N/A')}"
            
            output.append(f"{name:<20} {cpu:<12} {mem:<20} {net:<25} {block:<25}")
        
        return "\n".join(output)
    
    def monitor_resources(self, interval: int = 5, duration: int = 60) -> None:
        """
        持续监控资源使用情况
        
        Args:
            interval (int): 监控间隔（秒）
            duration (int): 监控持续时间（秒）
        """
        logger.info(f"开始监控容器资源，间隔{interval}秒，持续{duration}秒")
        
        start_time = time.time()
        while time.time() - start_time < duration:
            stats = self.get_container_stats()
            if stats:
                print("\033[2J\033[H")  # 清屏并移动光标到左上角
                print("=== 容器资源监控 ===")
                print(self.format_stats(stats))
                print(f"\n更新时间: {time.strftime('%Y-%m-%d %H:%M:%S')}")
            
            time.sleep(interval)
        
        logger.info("资源监控结束")

# 使用示例
if __name__ == "__main__":
    try:
        # 创建监控器实例
        monitor = DockerResourceMonitor()
        
        # 获取当前容器统计信息
        print("=== 当前容器资源使用情况 ===")
        stats = monitor.get_container_stats()
        if stats:
            print(monitor.format_stats(stats))
        else:
            print("无法获取容器统计信息")
        
        # 持续监控（仅作演示，实际使用时可以取消注释）
        # monitor.monitor_resources(interval=3, duration=30)
        
    except Exception as e:
        print(f"程序执行出错: {e}")
6.2 日志收集和分析

创建日志收集脚本：

# -*- coding: utf-8 -*-
"""
Docker容器日志收集和分析脚本
该脚本用于收集和分析Docker容器的日志
"""

import subprocess
import re
import json
import logging
from typing import Dict, List, Optional
from datetime import datetime
from collections import defaultdict

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class DockerLogAnalyzer:
    """Docker日志分析器"""
    
    def __init__(self):
        """初始化分析器"""
        self.error_patterns = [
            (re.compile(r'ERROR|error|Error'), '错误'),
            (re.compile(r'WARN|warn|Warning'), '警告'),
            (re.compile(r'EXCEPTION|exception'), '异常'),
            (re.compile(r'FATAL|fatal'), '致命错误')
        ]
    
    def collect_logs(self, service_name: str, lines: int = 100) -> Optional[List[str]]:
        """
        收集服务日志
        
        Args:
            service_name (str): 服务名称
            lines (int): 收集的日志行数
            
        Returns:
            Optional[List[str]]: 日志行列表
        """
        try:
            cmd = ["docker-compose", "logs", "--tail", str(lines), service_name]
            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
            return result.stdout.strip().split('\n')
            
        except subprocess.CalledProcessError as e:
            logger.error(f"收集{service_name}服务日志失败: {e.stderr}")
            return None
        except Exception as e:
            logger.error(f"收集{service_name}服务日志时发生未知错误: {e}")
            return None
    
    def analyze_logs(self, logs: List[str]) -> Dict:
        """
        分析日志内容
        
        Args:
            logs (List[str]): 日志行列表
            
        Returns:
            Dict: 分析结果
        """
        if not logs:
            return {"error": "没有日志数据"}
        
        analysis = {
            "total_lines": len(logs),
            "error_count": 0,
            "warning_count": 0,
            "exception_count": 0,
            "fatal_count": 0,
            "errors": [],
            "warnings": [],
            "timestamp_range": {}
        }
        
        # 统计各类问题
        for line in logs:
            for pattern, category in self.error_patterns:
                if pattern.search(line):
                    analysis[f"{category}_count"] += 1
                    if category == '错误':
                        analysis["errors"].append(line)
                    elif category == '警告':
                        analysis["warnings"].append(line)
        
        # 分析时间范围
        timestamps = []
        timestamp_pattern = re.compile(r'\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}')
        for line in logs:
            match = timestamp_pattern.search(line)
            if match:
                try:
                    timestamp = datetime.fromisoformat(match.group().replace('Z', '+00:00'))
                    timestamps.append(timestamp)
                except ValueError:
                    continue
        
        if timestamps:
            analysis["timestamp_range"] = {
                "start": min(timestamps).isoformat(),
                "end": max(timestamps).isoformat()
            }
        
        return analysis
    
    def generate_report(self, service_name: str, analysis: Dict) -> str:
        """
        生成分析报告
        
        Args:
            service_name (str): 服务名称
            analysis (Dict): 分析结果
            
        Returns:
            str: 分析报告
        """
        if "error" in analysis:
            return f"服务 {service_name} 日志分析失败: {analysis['error']}"
        
        report = []
        report.append(f"=== {service_name} 服务日志分析报告 ===")
        report.append(f"报告生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        report.append("")
        report.append("基础统计:")
        report.append(f"  总日志行数: {analysis['total_lines']}")
        report.append(f"  错误数量: {analysis['error_count']}")
        report.append(f"  警告数量: {analysis['warning_count']}")
        report.append(f"  异常数量: {analysis['exception_count']}")
        report.append(f"  致命错误数量: {analysis['fatal_count']}")
        
        if analysis["timestamp_range"]:
            report.append("")
            report.append("时间范围:")
            report.append(f"  开始时间: {analysis['timestamp_range']['start']}")
            report.append(f"  结束时间: {analysis['timestamp_range']['end']}")
        
        if analysis["errors"]:
            report.append("")
            report.append("最近的错误日志 (最多显示5条):")
            for error in analysis["errors"][-5:]:
                report.append(f"  {error}")
        
        if analysis["warnings"]:
            report.append("")
            report.append("最近的警告日志 (最多显示5条):")
            for warning in analysis["warnings"][-5:]:
                report.append(f"  {warning}")
        
        return "\n".join(report)

# 使用示例
if __name__ == "__main__":
    try:
        # 创建分析器实例
        analyzer = DockerLogAnalyzer()
        
        # 分析API服务日志
        print("=== 分析API服务日志 ===")
        api_logs = analyzer.collect_logs("api", lines=50)
        if api_logs:
            api_analysis = analyzer.analyze_logs(api_logs)
            print(analyzer.generate_report("api", api_analysis))
        else:
            print("无法收集API服务日志")
        
        print("\n" + "="*50 + "\n")
        
        # 分析数据库服务日志
        print("=== 分析数据库服务日志 ===")
        db_logs = analyzer.collect_logs("db", lines=50)
        if db_logs:
            db_analysis = analyzer.analyze_logs(db_logs)
            print(analyzer.generate_report("db", db_analysis))
        else:
            print("无法收集数据库服务日志")
        
    except Exception as e:
        print(f"程序执行出错: {e}")

7. 注意事项

7.1 内存限制

根据宿主机的可用内存，合理设置服务的内存限制：

services:
  api:
    deploy:
      resources:
        limits:
          memory: 512M  # 根据实际需求调整
7.2 安全配置

确保数据库和缓存服务的密码足够复杂：

# 在.env文件中使用强密码
POSTGRES_PASSWORD=StrongP@ssw0rd123!
REDIS_PASSWORD=AnotherStr0ngP@ssw0rd!
7.3 监控资源使用

使用docker stats命令监控容器的资源使用情况：

# 监控所有容器
docker stats

# 监控特定容器
docker stats api db redis

8. 最佳实践

8.1 分离配置文件

将配置文件（如.env和docker-compose-template.yaml）与代码分离，便于维护：

# 推荐的项目结构
dify-ai-system/
├── docker-compose.yml
├── .env
├── .env.example
├── volumes/
│   ├── app/
│   ├── db/
│   ├── redis/
│   └── weaviate/
└── scripts/
    ├── deploy.sh
    ├── backup.sh
    └── monitor.py
8.2 定期备份数据

定期备份数据库和存储卷中的数据，防止数据丢失：

#!/bin/bash
# backup.sh - 数据备份脚本

# 备份PostgreSQL数据库
docker-compose exec db pg_dump -U postgres dify > backup/dify_$(date +%Y%m%d_%H%M%S).sql

# 备份Redis数据
docker-compose exec redis redis-cli --rdb /data/dump_$(date +%Y%m%d_%H%M%S).rdb

# 备份向量数据库
docker-compose exec weaviate tar -czf /var/lib/weaviate/backup_$(date +%Y%m%d_%H%M%S).tar.gz /var/lib/weaviate

echo "数据备份完成: $(date)"
8.3 优化性能

根据实际需求调整服务的资源配置，提高系统性能：

services:
  db:
    command: >
      postgres 
      -c 'max_connections=200'
      -c 'shared_buffers=256MB'
      -c 'work_mem=8MB'
      -c 'maintenance_work_mem=128MB'

9. 常见问题

9.1 如何更新服务配置？

修改docker-compose.yaml文件后，运行以下命令重新部署服务：

# 重新部署服务
docker-compose up --force-recreate

# 或者只更新特定服务
docker-compose up --force-recreate api
9.2 如何查看服务日志？

使用docker-compose logs命令查看服务日志：

# 查看所有服务日志
docker-compose logs

# 查看特定服务日志
docker-compose logs api

# 实时跟踪日志
docker-compose logs -f

# 查看最近100行日志
docker-compose logs --tail 100
9.3 如何扩展服务实例？

使用--scale选项扩展服务实例：

# 扩展API服务到3个实例
docker-compose up --scale api=3
9.4 如何处理容器启动失败？
# 查看容器状态
docker-compose ps

# 查看容器日志
docker-compose logs <service_name>

# 进入容器调试
docker-compose exec <service_name> sh

# 重新构建容器
docker-compose build --no-cache <service_name>

10. 扩展阅读

10.1 官方文档
10.2 相关技术资源
AI应用部署
Docker容器化
微服务架构
云原生技术
Docker Compose
Kubernetes
Docker Swarm
服务发现
负载均衡
配置管理
容器编排
服务网格
监控告警
10.3 学习路径建议
2025-08-03 2025-08-10 2025-08-17 2025-08-24 2025-08-31 2025-09-07 2025-09-14 2025-09-21 2025-09-28 2025-10-05 2025-10-12 Docker基础 Docker Compose 容器网络 多服务编排 资源监控 日志管理 部署AI应用 性能优化 故障排查 基础知识 进阶技能 实战项目 AI应用部署学习路径

11. 总结

本文详细介绍了如何使用Docker Compose部署和管理一个完整的AI应用系统。通过合理的架构设计和服务配置，可以实现高效、可扩展的AI应用部署。关键要点总结如下：

11.1 核心要点
  1. 架构设计：合理设计系统架构，明确各组件职责
  2. 环境准备：正确安装和配置Docker及Docker Compose
  3. 配置管理：使用环境变量和配置文件管理服务配置
  4. 资源优化：根据实际需求调整资源分配
  5. 监控运维：建立完善的监控和日志管理机制
11.2 实践建议

在这里插入图片描述

11.3 未来发展方向
  1. 容器编排：从Docker Compose迁移到Kubernetes
  2. 服务网格：引入Istio等服务网格技术
  3. 自动化运维：使用Ansible、Terraform等工具实现基础设施即代码
  4. 云原生部署：在AWS、Azure、GCP等云平台上部署AI应用

通过本文的学习，您应该能够：

  • 熟练使用Docker Compose部署AI应用
  • 理解容器化部署的核心概念
  • 掌握服务编排和资源配置方法
  • 建立完善的监控和运维体系

希望本文能对您有所帮助，如果您有任何问题或建议，欢迎在评论区留言。

参考资料

图表示例

架构图
用户
Web前端
API服务
数据库
PostgreSQL
缓存服务
Redis
向量数据库
Weaviate/Qdrant/Milvus
AI模型服务
管理员
监控系统
开发者
日志系统

流程图
是
否
是
否
开始部署
检查环境
环境是否就绪?
创建目录结构
安装依赖
配置docker-compose.yml
配置.env文件
启动服务
服务是否正常?
部署完成
排查问题

思维导图

在这里插入图片描述

mindmap
  root((AI应用部署))
    Docker基础
      安装配置
      基本命令
      镜像管理
    Docker Compose
      服务定义
      网络配置
      存储卷管理
    AI服务组件
      API服务
        业务逻辑
        接口设计
      数据库服务
        PostgreSQL
        数据模型
      缓存服务
        Redis配置
        性能优化
      向量数据库
        Weaviate
        Qdrant
        Milvus
    部署实践
      环境准备
      配置管理
      服务启动
      监控运维
    最佳实践
      资源优化
      安全配置
      备份策略
      故障处理

甘特图

2025-08-01 2025-08-03 2025-08-05 2025-08-07 2025-08-09 2025-08-11 2025-08-13 2025-08-15 2025-08-17 2025-08-19 2025-08-21 2025-08-23 2025-08-25 2025-08-27 2025-08-29 安装Docker 安装Docker Compose 配置环境变量 设计架构 编写docker-compose.yml 配置各服务参数 创建目录结构 启动基础服务 启动AI相关服务 功能测试 性能优化 安全加固 正式部署 监控配置 文档编写 环境准备 服务配置 部署实施 测试优化 上线运维 AI应用部署项目计划

饼图

在这里插入图片描述

时序图

用户 Web前端 API服务 数据库 向量数据库 发起请求 转发请求 查询结构化数据 返回数据 查询向量数据 返回向量 处理AI逻辑 返回结果 展示结果 用户 Web前端 API服务 数据库 向量数据库

您可能感兴趣的与本文相关的镜像

ComfyUI

ComfyUI

AI应用
ComfyUI

ComfyUI是一款易于上手的工作流设计工具，具有以下特点：基于工作流节点设计，可视化工作流搭建，快速切换工作流，对显存占用小，速度快，支持多种插件，如ADetailer、Controlnet和AnimateDIFF等

【AI对话工具】使用 Docker Compose 部署 LobeChat教程
代码简单说 Vue、JAVA、PHP、Node.js 熟练运用，接口、架构、性能全搞定。
02-13 354
通过 Docker Compose 部署 LobeChat 服务，你可以轻松地管理和更新 LobeChat 实例。而使用定时任务来自动更新镜像和容器，确保你的服务始终保持最新的版本。希望这篇文章能够帮助你顺利部署 LobeChat！
使用docker-compose部署一个springboot项目(包含Postgres edisMongoNginx等环境)
洛阳泰山的博客
10-24 837
这是所有服务的开始标签，每个服务都是一个独立运行的应用程序或数据库实例。ports:networks:- mongo- postgres- redisimage: 使用的镜像是。: 容器启动后，其名称将设置为。ports: 将容器内的端口12000映射到宿主机的端口12000。networks: 容器将连接到名为的网络。depends_on: 指定了依赖的服务列表，这些服务在启动之前会被先启动。restart: 设置为always。
Docker部署AI算法教程
11-05 2428
docker上部署算法除了一些推理框架外，有时候会自己用torch推理加上一些web应用，下面写下自己用的一套方法。 Docker+cuda10.1+miniconda3+torch1.7.1 docker要求19.03以上才支持cuda 1.安装docker，我这里使用的centos7 $ sudo yum install -y yum-utils device-mapper-persistent-data lvm2 $ sudo yum-config-manager --add-repo ht
AI 算法加密与Docker 镜像部署
EncodingLee的博客
08-21 1458
Docker 是一种容器化平台，允许开发人员将应用程序及其所有依赖项打包到一个独立的容器中。这个容器可以在任何支持 Docker 的环境中运行，确保了应用程序在不同环境中具有相同的行为。
AI模型部署全攻略：Docker与Kubernetes实战指南！
最新发布
2401_85343303的博客
09-25 712
本文详细介绍了AI模型部署的容器化与云原生技术。首先阐述了容器化(Docker)的优势，包括环境一致性、依赖隔离和版本管理；然后介绍了Kubernetes的核心组件及其在AI部署中的应用；最后讲解了NVIDIA Triton推理平台的架构和工作流程。文章强调了容器化与云原生技术如何解决AI模型部署中的环境兼容、弹性伸缩、资源调度等工程挑战，为AI从实验室到生产环境的落地提供了实用指导。
docker ai部署
weixin_40598518的博客
07-12 273
如何实现“docker AI部署” 流程图 #render_6_977879163-svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#render_6_977879163-svg .error-icon{fi...
用通俗易懂的方式讲解大模型：使用 Docker 部署大模型的训练环境
2301_78285120的博客
12-30 7416
Docker 安装与主机安装的方式相比，我们少安装了 CUDA 和 PyTorch 程序，多安装了和下载 Docker 镜像，但整体花费的时间其实是减少了的（因为 CUDA 和 PyToch 安装时间比较长）。Docker 安装最大的好处就是可以随时切换不同的环境，而且不会影响到主机的环境。
江大白 | AI项目部署必备，Docker 万字实战教程：从入门到掌握（建议收藏！）
csdn_xmj的博客
05-22 1576
在AI项目部署过程中，Docker的使用是一个必备的技能，而Docker 是一个开源的应用容器引擎，它允许开发者将应用以及依赖打包到一个可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。本文将带你从Docker的基本概念开始，一步步深入到实际应用。
(十)将AI Docker容器部署到云端
寒冰屋的专栏
02-21 762
​ Docker等容器技术可简化依赖项管理并提高软件的可移植性。在本系列文章中，我们探讨了Docker在机器学习(ML)场景中的使用。 本系列假设您熟悉AI/ML、容器化，尤其是Docker。 在上一篇文章中，我们使用Fast API和Gunicorn调试了通过Rest API服务公开的NLP模型。 ​
Spring Cloud部署篇2——Docker Compose部署至CentOS云服务器
yangzhenyu2的博客
03-11 1431
本次部署的是基于Spring Cloud的微服务项目，需要将现有的gateway网关模块、mingink-system系统服务模块、mingink-article文章服务模块分别打成Jar，上传到CentOS云服务器，再使用docker compose进行快速部署。在上面的 mysql 中创建好 nacos_config 数据库后，需要在创建日志目录 /usr/soft/docker/mingink/nacos/logs。与环境部署一样，我们可以编写业务服务的 Docker Compose 文件。
使用 Docker Compose 部署 Ollama、Ollama Web UI、Mistral NeMo 与 DeepSeek R1 搭建本地类 ChatGPT 应用程序
08-30
通过 ChatOllama 的 Docker Compose 配置，可借助 Ollama 运行类 ChatGPT 的本地应用，默认会开启 WebUI，提供 Mistral NeMo 和 DeepSeek-R1-Distill-Lama-8B 两种模型供试用。 使用方式简单：启动服务后，会自动...
用docker compose部署vue+springboot最简单教程
程序员柚子的博客
08-12 721
简单快速教学用docker compose部署vue+springboot网站
大模型部署：使用docker部署本地离线AI大模型
m0_56255097的博客
08-10 3395
学习AI大模型是一个系统的过程，需要从基础开始，逐步深入到更高级的技术。这里给大家精心整理了一份全面的AI大模型学习资源，包括：AI大模型全套学习路线图（从入门到实战）、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频，免费分享！
Docker Compose 部署 AI 应用：从零到运行的完整指南
加入“Super Entity”，与全能开发团队共探AI智能体与数字人项目，开启前沿技术之旅。
08-14 1154
随着人工智能技术的迅猛发展，越来越多的开发者需要在本地或服务器上部署复杂的AI应用。Docker Compose作为一种简单高效的多容器应用管理工具，为AI应用的部署提供了极大的便利。本文将通过一个完整的AI应用案例，详细介绍如何使用Docker Compose配置、启动和管理多个服务，包括API服务、数据库、缓存、向量数据库等核心组件。文章将涵盖系统架构设计、服务部署、日志管理、常见问题排查等关键环节，并提供详细的代码示例和多种可视化图表。
Orange AI 管理平台单体版安装教程（Docker Compose 部署）
hengzq的博客
08-04 580
本文提供了Orange AI管理平台单体版的Docker Compose部署教程。首先需要准备Docker环境，然后克隆源码至本地。通过简单的docker compose命令即可启动包含后端、前端、MySQL和Milvus向量数据库的服务。部署完成后，可通过localhost访问平台（默认账号admin/hengzq.cn），或通过8080端口查看API文档。教程还包含常见问题解答链接和平台效果预览图，适合开发者和运维人员快速搭建测试环境。
linux 通过docker 部署ai
2301_77236938的博客
07-10 269
由于我的服务器配置比较低(配置是4g运行内存/cpu 两颗) 所以采用的是 qwen:0.5b(百度的通义千问) 这个模型 大概使用cpu 是2g 作用 本地虚拟机是可以正常跑的。基本上 只要大于1b的就不能只需要cpu了 需要用到gpu的性能 (开始上显卡)下载前 你可以查看deepseek 官网 来对应版本 一定要时刻关注cpu。查看相应的版本 一般来说0.7b 是4g 内存运行的极限(未测试)例如我的我的电脑 4060 +32G 是可以满血跑8b的ai模型。
AI工程部署（一）：Docker微服务【标准工作流：①构建阶段（编写Dockerfile，构建镜像； 将镜像push到dockerhub）；②部署阶段（从dockerhub上pull镜像； run）】
u013250861的博客
02-12 1498
一、构建镜像 1、编写Dockerfile # 声明基础镜像版本，选择pytorch官方镜像 FROM pytorch/pytorch:1.3-cuda10.1-cudnn7-runtime # 声明维护者 MAINTAINER old-wei <old-wei@gmail.com> # 首先拷贝requirements.txt进docker COPY ./requirements.txt /requirements.txt # 安装python依赖（如果安装较慢，请更换国内pip源：-i
使用Docker进行模型部署
weixin_43329319的博客
08-27 1618
文章目录1、思路2、实现步骤2.1 数据、模型准备2.2 镜像制作2.3 使用 1、思路 因为多数公司正式集群都不能使用公网环境，对于模型部署比较麻烦。所以想这在公网环境下完成模型调试，然后根据相关环境和参数直接制作一个docker镜像，部署到内网集群。 2、实现步骤 2.1 数据、模型准备 假设已经有一个模型文件，主函数predict，只要将 train_df, test_df传入即可得到结果。 首先，传输时候要转换成json，另外要将数据类型传输过来。 # 数据类型转换为dict test_df_dty
Docker+AI 整合：私有部署系统构建全流程揭秘
Sapphire521的博客
03-29 291
在现代软件开发中，Docker与人工智能（AI）的结合，正成为企业解决高效应用部署与智能化服务的重要手段。无论是云计算、大数据分析，还是深度学习的加速应用，Docker和AI的深度整合能够为企业提供快速、稳定、高效的系统部署。本文将从Docker技术与AI模型集成的多个层面出发，详细揭秘私有部署系统的构建过程，探索这一技术整合如何推动智能化应用的实现，并带来超前思维的技术创新。
使用Docker Compose部署Python与MySQL项目实践
7. **部署与测试**：使用Docker Compose一键部署和测试整个应用，包括前端、后端和数据库服务，理解如何在本地或云环境中进行容器化应用的部署和管理。 在实际操作过程中，开发者需要确保Docker环境已经安装在本地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CarlowZJ

我的文章对你有用的话，可以支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值