基于Docker Compose的AI应用部署与优化实践完整指南

最新推荐文章于 2025-12-19 16:18:12 发布
原创 最新推荐文章于 2025-12-19 16:18:12 发布 · 1k 阅读 · 28 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#docker #人工智能 #容器 #Docker #Docker Compose #AI #部署

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

摘要

随着人工智能技术的飞速发展，越来越多的开发者开始将AI应用部署到生产环境中。Docker Compose作为一种流行的容器编排工具，为AI应用的部署提供了极大的便利。然而，在实际部署过程中，开发者常常会遇到各种问题，如内存不足、容器不断重启、架构不匹配等。本文将通过实际案例，详细介绍如何使用Docker Compose部署和优化AI应用，特别是针对资源受限环境下的问题排查和优化。文章适合中国开发者，尤其是AI应用开发者，提供了详细的实践示例和最佳实践建议。

正文

1. 引言

在当今快速发展的AI技术领域，将AI模型和应用部署到生产环境已成为许多企业和开发团队的核心需求。然而，AI应用通常具有资源密集、依赖复杂、性能要求高等特点，这使得部署过程变得极具挑战性。

Docker Compose作为一种轻量级的容器编排工具，为解决这些挑战提供了有效途径。它允许开发者通过一个YAML文件定义和运行多容器Docker应用程序，大大简化了复杂AI系统的部署和管理过程。

本文将深入探讨如何使用Docker Compose部署AI应用，并重点介绍在资源受限环境下的优化策略和问题排查方法。通过实际案例和代码示例，帮助开发者快速掌握相关技能。

2. 环境准备

2.1 系统要求

在开始部署AI应用之前，需要确保系统满足以下基本要求：

  • 操作系统：Linux（推荐Ubuntu 20.04+）、macOS或Windows（WSL2）
  • 内存：至少8GB RAM（推荐16GB以上）
  • 存储：至少20GB可用磁盘空间
  • Docker：版本19.03或更高
  • Docker Compose：版本1.27或更高
2.2 工具安装

以下是Ubuntu系统上的安装步骤：

# 更新包索引
sudo apt-get update

# 安装必要的包
sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

# 添加Docker官方GPG密钥
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 设置稳定版仓库
echo \
  "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 安装Docker Engine
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

# 安装Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# 验证安装
docker --version
docker-compose --version

3. 最小化配置实践

3.1 最小化配置示例

为了快速定位问题，我们首先将Docker Compose配置精简到最小化，只保留必要的服务。以下是一个最小化的[mini.yml](file:///C:/Users/13532/Desktop/%E5%8D%9A%E5%AE%A2/.history/mini.yml)文件示例：

# mini.yml - 最小化AI应用部署配置
version: '3.8'

services:
  redis:
    image: redis:7-alpine
    command: redis-server --port 6381
    networks: [backend]
    ports:
      - "6381:6381"

  playwright-service:
    image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/ghcr.io/mendableai/playwright-service:latest
    environment:
      PORT: 3000
    networks: [backend]
    ports:
      - "3000:3000"

  worker:
    image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/ghcr.io/mendableai/firecrawl:latest
    environment:
      REDIS_URL: redis://redis:6381
      REDIS_RATE_LIMIT_URL: redis://redis:6381
      PLAYWRIGHT_MICROSERVICE_URL: http://playwright-service:3000/scrape
      NUM_WORKERS_PER_QUEUE: 1
    depends_on: 
      - redis
      - playwright-service
    networks: [backend]
    command: ["pnpm", "run", "workers"]

networks:
  backend:
    driver: bridge
3.2 启动最小化配置

保存上述配置为[mini.yml](file:///C:/Users/13532/Desktop/%E5%8D%9A%E5%AE%A2/.history/mini.yml)，然后使用以下命令启动服务：

# 启动最小化配置
docker compose -p mini -f mini.yml up --build

# 在后台启动
docker compose -p mini -f mini.yml up -d

# 查看服务状态
docker compose -p mini -f mini.yml ps

# 查看服务日志
docker compose -p mini -f mini.yml logs
3.3 系统架构图

以下是系统的架构图，展示了各组件之间的关系：
客户端
API服务
Redis缓存
Playwright服务
Worker服务
数据存储
网页数据

4. 问题排查与优化

4.1 常见问题类型

在AI应用部署过程中，常见的问题包括：

  1. 内存不足：容器分配的内存不足以支持应用运行
  2. 架构不匹配：容器的架构与宿主机不匹配，导致兼容性问题
  3. 依赖服务未就绪：服务启动顺序不当导致依赖服务未准备好
  4. 网络连接问题：服务间网络通信异常
  5. 资源竞争：多个服务竞争同一资源
4.2 问题排查工具
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
AI应用部署问题排查工具
用于诊断和分析Docker Compose部署中的常见问题
"""

import docker
import psutil
import time
import json
from typing import Dict, List
import subprocess

class DeploymentDiagnostic:
    """部署诊断工具"""
    
    def __init__(self, project_name: str = "mini"):
        """
        初始化诊断工具
        
        Args:
            project_name (str): Docker Compose项目名称
        """
        self.project_name = project_name
        try:
            self.client = docker.from_env()
            print("✅ Docker客户端初始化成功")
        except Exception as e:
            print(f"❌ Docker客户端初始化失败: {e}")
            raise
    
    def check_system_resources(self) -> Dict:
        """
        检查系统资源使用情况
        
        Returns:
            Dict: 系统资源使用情况
        """
        # CPU使用率
        cpu_percent = psutil.cpu_percent(interval=1)
        
        # 内存使用情况
        memory = psutil.virtual_memory()
        
        # 磁盘使用情况
        disk = psutil.disk_usage('/')
        
        return {
            'cpu_percent': cpu_percent,
            'memory_total_gb': round(memory.total / (1024**3), 2),
            'memory_used_gb': round(memory.used / (1024**3), 2),
            'memory_percent': memory.percent,
            'disk_total_gb': round(disk.total / (1024**3), 2),
            'disk_used_gb': round(disk.used / (1024**3), 2),
            'disk_percent': round((disk.used / disk.total) * 100, 2)
        }
    
    def check_docker_resources(self) -> Dict:
        """
        检查Docker资源限制
        
        Returns:
            Dict: Docker资源信息
        """
        try:
            # 获取Docker信息
            info = self.client.info()
            
            # 获取Docker资源限制
            total_memory = info.get('MemTotal', 0)
            total_cpus = info.get('NCPU', 0)
            
            return {
                'total_memory_gb': round(total_memory / (1024**3), 2) if total_memory > 0 else 0,
                'total_cpus': total_cpus,
                'docker_version': info.get('ServerVersion', 'unknown')
            }
        except Exception as e:
            print(f"获取Docker资源信息失败: {e}")
            return {}
    
    def get_container_status(self) -> List[Dict]:
        """
        获取项目容器状态
        
        Returns:
            List[Dict]: 容器状态列表
        """
        try:
            # 使用docker-compose命令获取服务状态
            result = subprocess.run([
                "docker-compose", 
                "-p", self.project_name, 
                "ps", "--format", "json"
            ], capture_output=True, text=True)
            
            if result.returncode == 0:
                # 解析JSON输出
                containers = []
                for line in result.stdout.strip().split('\n'):
                    if line:
                        container_info = json.loads(line)
                        containers.append(container_info)
                return containers
            else:
                print(f"获取容器状态失败: {result.stderr}")
                return []
        except Exception as e:
            print(f"获取容器状态时发生错误: {e}")
            return []
    
    def analyze_container_logs(self, container_name: str, lines: int = 50) -> str:
        """
        分析容器日志，查找常见错误
        
        Args:
            container_name (str): 容器名称
            lines (int): 获取日志行数
            
        Returns:
            str: 日志分析结果
        """
        try:
            # 获取容器日志
            container = self.client.containers.get(container_name)
            logs = container.logs(tail=lines).decode('utf-8')
            
            # 分析常见错误模式
            issues = []
            
            if "OOMKilled" in logs:
                issues.append("❌ 内存不足导致容器被终止")
            
            if "WORKER STALLED" in logs:
                issues.append("⚠️  Worker进程停滞")
            
            if "Cant accept connection" in logs:
                issues.append("⚠️  连接失败")
            
            if "segmentation fault" in logs.lower():
                issues.append("❌ 段错误，可能是架构不匹配")
            
            if "architecture mismatch" in logs.lower():
                issues.append("❌ 架构不匹配")
            
            return "\n".join(issues) if issues else "✅ 未发现明显错误"
        except Exception as e:
            return f"❌ 日志分析失败: {e}"
    
    def print_diagnostic_report(self):
        """打印诊断报告"""
        print("\n" + "="*60)
        print("🔍 AI应用部署诊断报告")
        print("="*60)
        
        # 系统资源检查
        print("\n💻 系统资源使用情况:")
        system_resources = self.check_system_resources()
        print(f"  CPU使用率: {system_resources['cpu_percent']}%")
        print(f"  内存总量: {system_resources['memory_total_gb']}GB")
        print(f"  已用内存: {system_resources['memory_used_gb']}GB ({system_resources['memory_percent']}%)")
        print(f"  磁盘总量: {system_resources['disk_total_gb']}GB")
        print(f"  已用磁盘: {system_resources['disk_used_gb']}GB ({system_resources['disk_percent']}%)")
        
        # Docker资源检查
        print("\n🐳 Docker资源配置:")
        docker_resources = self.check_docker_resources()
        if docker_resources:
            print(f"  Docker版本: {docker_resources['docker_version']}")
            print(f"  总内存: {docker_resources['total_memory_gb']}GB")
            print(f"  CPU核心数: {docker_resources['total_cpus']}")
        
        # 容器状态检查
        print("\n📦 容器状态:")
        containers = self.get_container_status()
        if containers:
            for container in containers:
                name = container.get('Name', 'N/A')
                state = container.get('State', 'N/A')
                status_icon = "✅" if state == 'running' else "❌" if state in ['exited', 'dead'] else "⚠️"
                print(f"  {status_icon} {name}: {state}")
                
                # 分析容器日志
                if state != 'running':
                    log_analysis = self.analyze_container_logs(name)
                    print(f"    日志分析: {log_analysis}")
        else:
            print("  未获取到容器信息")

def main():
    """主函数"""
    diagnostic = DeploymentDiagnostic("mini")
    diagnostic.print_diagnostic_report()

if __name__ == "__main__":
    main()
4.3 优化实践
4.3.1 内存优化

如果发现内存不足，可以尝试以下方法：

# 优化后的docker-compose.yml - 内存优化配置
version: '3.8'

services:
  redis:
    image: redis:7-alpine
    command: redis-server --port 6381
    networks: [backend]
    ports:
      - "6381:6381"
    deploy:
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M

  playwright-service:
    image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/ghcr.io/mendableai/playwright-service:latest
    environment:
      PORT: 3000
    networks: [backend]
    ports:
      - "3000:3000"
    deploy:
      resources:
        limits:
          memory: 1G
        reservations:
          memory: 512M
    shm_size: 2gb

  worker:
    image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/ghcr.io/mendableai/firecrawl:latest
    environment:
      REDIS_URL: redis://redis:6381
      REDIS_RATE_LIMIT_URL: redis://redis:6381
      PLAYWRIGHT_MICROSERVICE_URL: http://playwright-service:3000/scrape
      NUM_WORKERS_PER_QUEUE: 1  # 减少并发数
    depends_on: 
      - redis
      - playwright-service
    networks: [backend]
    command: ["pnpm", "run", "workers"]
    deploy:
      resources:
        limits:
          memory: 2G
        reservations:
          memory: 1G

networks:
  backend:
    driver: bridge
4.3.2 架构优化

如果发现架构不匹配，可以尝试以下方法：

# Dockerfile - 架构优化示例
FROM --platform=linux/amd64 python:3.9-slim

# 设置工作目录
WORKDIR /app

# 复制依赖文件
COPY requirements.txt .

# 安装依赖
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 8000

# 启动应用
CMD ["python", "app.py"]
4.3.3 实践示例

以下是一个Python脚本示例，用于模拟内存不足的情况，并展示如何通过减少并发来优化：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
内存优化示例脚本
演示如何在资源受限环境下优化AI应用
"""

import os
import time
import psutil
from typing import List

class MemoryOptimizer:
    """内存优化器"""
    
    def __init__(self):
        """初始化内存优化器"""
        self.process = psutil.Process()
    
    def get_memory_usage(self) -> float:
        """
        获取当前内存使用量(MB)
        
        Returns:
            float: 内存使用量(MB)
        """
        memory_info = self.process.memory_info()
        return memory_info.rss / (1024 * 1024)
    
    def simulate_memory_usage(self, size_mb: int = 100):
        """
        模拟内存使用
        
        Args:
            size_mb (int): 模拟内存使用量(MB)
        """
        print(f"📈 开始模拟使用 {size_mb}MB 内存...")
        start_memory = self.get_memory_usage()
        print(f"   初始内存使用: {start_memory:.2f}MB")
        
        # 创建大列表模拟内存使用
        large_list = [0] * (size_mb * 1024 * 128)  # 约size_mb MB
        
        end_memory = self.get_memory_usage()
        print(f"   模拟后内存使用: {end_memory:.2f}MB")
        print(f"   内存增长: {end_memory - start_memory:.2f}MB")
        
        # 模拟处理时间
        time.sleep(2)
        
        # 释放内存
        del large_list
        print("✅ 内存已释放")
    
    def adaptive_worker(self, max_workers: int = None):
        """
        自适应工作进程数
        
        Args:
            max_workers (int): 最大工作进程数
        """
        # 获取系统内存信息
        memory = psutil.virtual_memory()
        available_memory_gb = memory.available / (1024**3)
        
        # 根据可用内存动态调整工作进程数
        if max_workers is None:
            # 每2GB可用内存分配1个工作进程
            calculated_workers = max(1, int(available_memory_gb / 2))
            max_workers = min(calculated_workers, 8)  # 最多8个工作进程
        
        print(f"⚙️  系统可用内存: {available_memory_gb:.2f}GB")
        print(f"🔧 自适应工作进程数: {max_workers}")
        
        return max_workers

def main():
    """主函数"""
    optimizer = MemoryOptimizer()
    
    # 获取环境变量设置的并发数
    num_workers = int(os.getenv("NUM_WORKERS_PER_QUEUE", 1))
    print(f"🔧 环境变量设置的并发数: {num_workers}")
    
    # 自适应调整
    adaptive_workers = optimizer.adaptive_worker(num_workers)
    
    # 模拟工作进程
    for i in range(adaptive_workers):
        print(f"\n🔄 启动工作进程 {i+1}/{adaptive_workers}")
        try:
            # 根据进程号调整内存使用量
            memory_size = 50 + (i * 25)  # 每个进程使用50-250MB内存
            optimizer.simulate_memory_usage(memory_size)
        except MemoryError:
            print("❌ 内存不足，减少工作进程数")
            break
        except Exception as e:
            print(f"❌ 工作进程 {i+1} 出错: {e}")

if __name__ == "__main__":
    main()

5. 实践案例

5.1 案例背景

假设你正在部署一个AI网页内容分析应用，该应用包含Redis、Playwright服务和一个worker服务。在部署过程中，发现worker服务不断重启，导致应用无法正常运行。

5.2 问题定位

通过日志分析，发现worker服务在启动后不久就因内存不足而崩溃。通过减少并发数和增加内存分配，成功解决了问题。

5.3 解决方案实施
# production.yml - 生产环境优化配置
version: '3.8'

services:
  redis:
    image: redis:7-alpine
    command: redis-server --port 6381
    networks: [backend]
    ports:
      - "127.0.0.1:6381:6381"  # 仅本地访问
    deploy:
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M
    volumes:
      - redis-data:/data
    restart: unless-stopped

  playwright-service:
    image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/ghcr.io/mendableai/playwright-service:latest
    environment:
      PORT: 3000
      BLOCK_MEDIA: ${BLOCK_MEDIA:-true}
    networks: [backend]
    deploy:
      resources:
        limits:
          memory: 1G
        reservations:
          memory: 512M
    shm_size: 2gb
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:3000"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  worker:
    image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/ghcr.io/mendableai/firecrawl:latest
    environment:
      REDIS_URL: redis://redis:6381
      REDIS_RATE_LIMIT_URL: redis://redis:6381
      PLAYWRIGHT_MICROSERVICE_URL: http://playwright-service:3000/scrape
      NUM_WORKERS_PER_QUEUE: ${NUM_WORKERS_PER_QUEUE:-2}  # 默认2个并发
      LOGGING_LEVEL: ${LOGGING_LEVEL:-INFO}
    depends_on: 
      redis:
        condition: service_started
      playwright-service:
        condition: service_healthy
    networks: [backend]
    command: ["pnpm", "run", "workers"]
    deploy:
      replicas: ${WORKER_REPLICAS:-1}
      resources:
        limits:
          memory: 2G
        reservations:
          memory: 1G
    restart: unless-stopped

  api:
    image: swr.cn-north-4.myhuaweicloud.com/ddn-k8s/ghcr.io/mendableai/firecrawl:latest
    environment:
      REDIS_URL: redis://redis:6381
      REDIS_RATE_LIMIT_URL: redis://redis:6381
      PLAYWRIGHT_MICROSERVICE_URL: http://playwright-service:3000/scrape
      HOST: 0.0.0.0
      PORT: 8083
      LOGGING_LEVEL: ${LOGGING_LEVEL:-INFO}
    depends_on: 
      redis:
        condition: service_started
      playwright-service:
        condition: service_healthy
    networks: [backend]
    ports:
      - "8083:8083"
    command: ["pnpm", "run", "start:production"]
    deploy:
      resources:
        limits:
          memory: 1G
        reservations:
          memory: 512M
    restart: unless-stopped

networks:
  backend:
    driver: bridge

volumes:
  redis-data:
    driver: local
5.4 环境变量配置
# .env - 环境变量配置文件
NUM_WORKERS_PER_QUEUE=2
WORKER_REPLICAS=1
LOGGING_LEVEL=INFO
BLOCK_MEDIA=true
5.5 实施计划甘特图
2025-08-29 2025-08-31 2025-09-01 2025-09-03 2025-09-05 2025-09-07 2025-09-09 2025-09-11 2025-09-13 2025-09-15 2025-09-17 2025-09-19 系统环境检查 工具安装配置 最小化配置部署 问题诊断分析 优化方案实施 功能测试 性能测试 压力测试 生产环境部署 监控系统搭建 文档编写 环境准备 部署实施 测试验证 上线运维 AI应用部署与优化实施计划

6. 注意事项

6.1 资源分配
  • 内存分配：确保Docker分配的内存足够支持应用运行，建议至少8GB
  • CPU分配：根据应用需求合理分配CPU核心数
  • 磁盘空间：确保有足够的磁盘空间存储日志和数据
6.2 架构匹配
  • 使用本地镜像：使用与宿主机架构匹配的本地镜像
  • 调整Docker配置：确保Docker配置正确，支持目标架构
  • 交叉编译：在必要时使用交叉编译技术
6.3 日志分析
  • 日志级别：合理设置日志级别，避免过多无用信息
  • 日志轮转：配置日志轮转，防止日志文件过大
  • 错误监控：建立错误监控机制，及时发现和处理问题

7. 最佳实践

7.1 逐步排查
  • 从最小化配置开始：逐步排查问题，避免复杂配置干扰
  • 单一变量原则：每次只改变一个配置项，便于定位问题
  • 版本控制：使用版本控制管理配置文件变更
7.2 减少并发
  • 在资源受限的情况下减少并发数：降低系统负载
  • 动态调整：根据系统负载动态调整并发数
  • 队列管理：使用队列管理任务，避免资源竞争
7.3 监控资源
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
资源监控脚本
实时监控Docker Compose部署的AI应用资源使用情况
"""

import docker
import time
import json
from typing import Dict, List

class ResourceMonitor:
    """资源监控器"""
    
    def __init__(self, project_name: str = "mini"):
        """
        初始化资源监控器
        
        Args:
            project_name (str): Docker Compose项目名称
        """
        self.project_name = project_name
        try:
            self.client = docker.from_env()
            print("✅ Docker客户端初始化成功")
        except Exception as e:
            print(f"❌ Docker客户端初始化失败: {e}")
            raise
    
    def get_container_stats(self, container_name: str) -> Dict:
        """
        获取容器资源统计信息
        
        Args:
            container_name (str): 容器名称
            
        Returns:
            Dict: 容器资源统计信息
        """
        try:
            container = self.client.containers.get(container_name)
            stats = container.stats(stream=False)
            
            # CPU使用率计算
            cpu_stats = stats['cpu_stats']
            precpu_stats = stats['precpu_stats']
            cpu_delta = cpu_stats['cpu_usage']['total_usage'] - precpu_stats['cpu_usage']['total_usage']
            system_delta = cpu_stats['system_cpu_usage'] - precpu_stats['system_cpu_usage']
            
            if system_delta > 0 and cpu_delta > 0:
                cpu_percent = (cpu_delta / system_delta) * len(cpu_stats['cpu_usage']['percpu_usage']) * 100
            else:
                cpu_percent = 0.0
            
            # 内存使用情况
            memory_stats = stats['memory_stats']
            memory_usage = memory_stats.get('usage', 0) / (1024 * 1024)  # MB
            memory_limit = memory_stats.get('limit', 0) / (1024 * 1024)  # MB
            memory_percent = (memory_usage / memory_limit) * 100 if memory_limit > 0 else 0
            
            return {
                'container_name': container_name,
                'cpu_percent': round(cpu_percent, 2),
                'memory_usage_mb': round(memory_usage, 2),
                'memory_limit_mb': round(memory_limit, 2),
                'memory_percent': round(memory_percent, 2)
            }
        except Exception as e:
            print(f"获取容器 {container_name} 统计信息失败: {e}")
            return {}
    
    def monitor_project_resources(self):
        """监控项目资源使用情况"""
        try:
            # 获取项目中的所有容器
            containers = self.client.containers.list(filters={
                "label": f"com.docker.compose.project={self.project_name}"
            })
            
            print(f"\n📊 {self.project_name} 项目资源使用情况:")
            print("-" * 80)
            print(f"{'容器名称':<25} {'CPU使用率':<15} {'内存使用(MB)':<15} {'内存限制(MB)':<15} {'内存使用率':<15}")
            print("-" * 80)
            
            for container in containers:
                stats = self.get_container_stats(container.name)
                if stats:
                    print(f"{stats['container_name'][:24]:<25} "
                          f"{stats['cpu_percent']:<15} "
                          f"{stats['memory_usage_mb']:<15} "
                          f"{stats['memory_limit_mb']:<15} "
                          f"{stats['memory_percent']:<15}%")
            
            print("-" * 80)
        except Exception as e:
            print(f"监控项目资源时发生错误: {e}")

def main():
    """主函数"""
    monitor = ResourceMonitor("mini")
    
    try:
        while True:
            monitor.monitor_project_resources()
            print(f"\n⏱️  {time.strftime('%Y-%m-%d %H:%M:%S')} - 10秒后刷新，按 Ctrl+C 退出...")
            time.sleep(10)
    except KeyboardInterrupt:
        print("\n👋 资源监控已停止")

if __name__ == "__main__":
    main()
7.4 健康检查
services:
  playwright-service:
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:3000"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

8. 常见问题解答

8.1 容器不断重启怎么办？

问题现象：容器启动后很快重启，应用无法正常运行

解决方案：

  1. 检查日志：通过docker logs检查容器日志，查找错误信息

    docker compose -p mini -f mini.yml logs worker

  2. 减少并发：降低并发数，减少内存使用

    NUM_WORKERS_PER_QUEUE=1

  3. 增加内存：为Docker分配更多内存

    worker:
  deploy:
    resources:
      limits:
        memory: 4G
8.2 如何确保架构匹配？

问题现象：容器启动失败，日志中出现架构相关错误

解决方案：

  1. 使用本地镜像：使用与宿主机架构匹配的本地镜像

    docker build --platform linux/amd64 -t my-app .

  2. 调整Docker配置：确保Docker配置正确，支持目标架构

    docker run --platform linux/amd64 my-app
8.3 网络连接失败怎么办？

问题现象：服务间无法正常通信

解决方案：

  1. 检查网络配置：确保服务在同一网络中

    networks:
  backend:
    driver: bridge

  2. 使用服务名称：通过服务名称而非IP地址访问其他服务

    REDIS_URL=redis://redis:6381
8.4 如何优化启动时间？

解决方案：

  1. 健康检查：为服务添加健康检查，确保依赖服务就绪

    depends_on:
  redis:
    condition: service_healthy

  2. 并行启动：合理配置服务依赖，允许可以并行的服务同时启动

9. 扩展阅读

  1. Docker Compose官方文档: https://docs.docker.com/compose/
  2. Docker最佳实践: https://docs.docker.com/develop/develop-images/dockerfile_best-practices/
  3. Redis官方文档: https://redis.io/documentation/
  4. Playwright官方文档: https://playwright.dev/
  5. Python Docker SDK文档: https://docker-py.readthedocs.io/

10. 资源分布情况

20% 40% 30% 10% AI应用各服务资源分配比例 API服务 Worker服务 Playwright服务 Redis服务

总结

本文通过一个实际案例，详细展示了如何使用Docker Compose部署和优化AI应用。我们从最小化配置开始，逐步介绍了问题排查和优化实践，成功解决了应用部署中常见的问题。

关键要点总结：

  1. 最小化配置原则：从最简单的配置开始，逐步增加复杂性，有助于快速定位问题
  2. 资源监控重要性：实时监控资源使用情况，及时发现和解决资源瓶颈
  3. 自适应优化策略：根据系统资源动态调整应用配置，提高资源利用率
  4. 健康检查机制：通过健康检查确保服务依赖正确处理，提高系统稳定性
  5. 日志分析技巧：通过日志分析快速定位问题根源，提高排错效率

通过遵循这些最佳实践，AI应用开发者可以更高效地部署和优化基于Docker Compose的应用系统。在实际应用中，应根据具体业务场景和性能要求，灵活调整优化策略，持续改进系统性能。

参考资料

  1. Docker Compose官方文档
  2. Redis官方文档
  3. Playwright官方文档
  4. Docker最佳实践指南
  5. Python Docker SDK文档

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

ComfyUI

ComfyUI

AI应用
ComfyUI

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

58_AI智能体运维部署之实战指南：本地开发环境Docker Compose部署全记录
在科技的浪潮中，我们寻找着创新的火种，在代码的海洋里，我们编织着智慧的网。腾飞开源，就是这样一个由技术精英汇聚而成的博客平台，我们致力于分享在Java、Python、IoT和人工智能等领域的最新研究成果和实战经验。 在腾飞开源的博客上，你会看到紧跟技术前
11-13 236
本文详细介绍了在Docker Desktop本地环境使用Docker Compose部署服务的完整流程。涵盖环境清理、服务构建启动、状态监控和日志查看等关键环节，分享了端口冲突、构建失败等常见问题的解决方案，并提供了API文档访问和健康检查等验证方法，帮助开发者建立可靠的本地部署流程。
基于Docker Compose的AI应用开发与部署实践完整指南
加入“Super Entity”，与全能开发团队共探AI智能体与数字人项目，开启前沿技术之旅。
08-29 786
随着人工智能技术的迅猛发展，越来越多的应用需要集成AI功能。Docker Compose作为一种强大的容器编排工具，能够帮助开发者快速搭建和部署复杂的AI应用系统。本文将详细介绍如何使用Docker Compose构建一个包含Redis、Playwright服务、API服务和Worker服务的完整AI应用系统。通过实践示例，我们将展示如何解决常见的部署问题，优化系统性能，并提供最佳实践建议。
Docker Compose 部署 AI 应用：从零到运行的完整指南
加入“Super Entity”，与全能开发团队共探AI智能体与数字人项目，开启前沿技术之旅。
08-14 1198
随着人工智能技术的迅猛发展，越来越多的开发者需要在本地或服务器上部署复杂的AI应用。Docker Compose作为一种简单高效的多容器应用管理工具，为AI应用的部署提供了极大的便利。本文将通过一个完整的AI应用案例，详细介绍如何使用Docker Compose配置、启动和管理多个服务，包括API服务、数据库、缓存、向量数据库等核心组件。文章将涵盖系统架构设计、服务部署、日志管理、常见问题排查等关键环节，并提供详细的代码示例和多种可视化图表。
基于Docker Compose构建AI应用的完整实践指南
加入“Super Entity”，与全能开发团队共探AI智能体与数字人项目，开启前沿技术之旅。
08-29 443
随着人工智能技术的快速发展，AI应用已成为现代软件开发的重要组成部分。然而，构建和部署复杂的AI应用系统往往面临诸多挑战，包括环境配置复杂、服务依赖管理困难、资源调度复杂等问题。Docker Compose作为一种轻量级的容器编排工具，为解决这些问题提供了有效的解决方案。本文将详细介绍如何使用Docker Compose构建一个完整的AI应用系统，涵盖环境搭建、服务配置、问题排查、性能优化等关键环节。通过丰富的实践案例和代码示例，帮助中国开发者特别是AI应用开发者快速掌握相关技能，构建稳定、高效的AI应用系
Docker化AI应用部署全攻略：从Dify到RAGFlow的实践指南
加入“Super Entity”，与全能开发团队共探AI智能体与数字人项目，开启前沿技术之旅。
08-10 1430
随着人工智能技术的快速发展，越来越多的企业和开发者开始构建基于AI的应用系统。然而，AI应用的部署和运维往往比传统应用更加复杂，涉及多个服务组件的协调和管理。本文将详细介绍如何使用Docker Compose来部署和管理AI应用系统，涵盖从环境准备、服务配置到性能优化和监控的全过程。我们将以Dify和RAGFlow两个典型的AI应用平台为例，深入探讨部署过程中的关键问题和解决方案，包括内存溢出处理、性能调优、系统监控等。
Dify平台Docker Compose部署及常见问题解决完整指南
加入“Super Entity”，与全能开发团队共探AI智能体与数字人项目，开启前沿技术之旅。
08-14 1775
Dify是一个功能强大的开源AI应用开发平台，支持快速构建和部署各种AI应用。本文将详细介绍如何使用Docker Compose部署Dify平台，并针对部署过程中可能遇到的常见问题提供详细的排查和解决方法。通过实践示例、架构图和代码演示，帮助中国开发者特别是AI应用开发者快速掌握Dify平台的部署技巧，解决实际问题。文章将涵盖系统架构设计、部署配置、日志管理、问题排查、性能优化等关键环节，为读者提供一套完整的解决方案。
Docker Compose部署AI应用及故障排查完全指南
加入“Super Entity”，与全能开发团队共探AI智能体与数字人项目，开启前沿技术之旅。
08-30 817
在现代AI应用开发中，Docker Compose已成为部署和管理多容器应用的标准工具。本文面向中国开发者，特别是AI应用开发者，深入探讨如何使用Docker Compose高效部署AI应用，包括LightRAG、Memgraph等热门技术栈。文章通过丰富的实践案例、架构图、流程图等可视化内容，详细讲解Docker Compose的基本使用方法、常见问题排查技巧以及部署优化策略。我们将从基础概念入手，逐步深入到高级部署技巧和故障排查方法，帮助开发者快速掌握相关技术，提升AI应用的部署效率和稳定性。
FireCrawl的 Docker Compose 完全部署指南：从环境准备到生产实践
加入“Super Entity”，与全能开发团队共探AI智能体与数字人项目，开启前沿技术之旅。
08-30 1216
FireCrawl 是一个基于 AI 的强大网络爬虫系统，能够将任何网站转换为结构化数据，广泛应用于数据抓取、内容分析和AI训练等领域。本文面向中国开发者，特别是AI应用开发者，全面介绍如何使用 Docker Compose 部署 FireCrawl 项目。文章从环境准备、Docker Compose 文件编写、环境变量配置到服务启动与调试，通过丰富的实践案例、架构图、流程图等可视化内容，帮助开发者快速掌握 FireCrawl 的部署技巧。
Docker Compose多容器应用部署指南
matt78916的博客
06-21 453
Docker Compose是一个用于定义和运行多容器Docker应用程序的工具。它允许用户通过一个YAML文件配置应用程序的服务，然后使用一个命令启动所有服务。易于使用：Docker Compose通过简单的配置文件描述应用程序的组件，使得部署和管理多容器应用变得更加简单。灵活扩展：Docker Compose支持服务的扩展，用户可以根据需要调整服务的副本数量。本文详细介绍了Docker Compose多容器应用的部署方法，包括Docker Compose的安装与配置、多容器部署步骤以及高级特性。
Docker Compose 部署 Dify + Ollama 全栈指南：从裸奔到安全可观测的 AI 应用实战
加入“Super Entity”，与全能开发团队共探AI智能体与数字人项目，开启前沿技术之旅。
08-03 1853
本文以中国开发者视角出发，手把手教你用 Docker Compose 在本地或轻量云主机上部署组合栈，实现“安全、可观测、可扩展”的私有化 AI 应用平台。架构图、流程图、甘特图、思维导图等 6 种图表；10+ 段可直接复制的 Python 示例代码；5 大实战场景（RAG 知识库、代码助手、企业内部问答等）；常见 15 个“坑”及解决方案；从裸奔到 HTTPS + Basic Auth + IP 白名单的完整安全加固方案。读完即可在生产环境落地。维度达成情况安全性。
【Docker Compose】高级编排实战指南：涵盖Web全栈、AI/ML、IoT、监控、CI/CD等多领域应用部署摘要 本文
04-17
内容概要：本文深入探讨了 Docker Compose 的高级应用，旨在帮助用户从基础用户成长为能够驾驭复杂系统编排的专家。文章首先介绍了 Docker Compose 的核心高级特性，如 profiles、extends、depends_on、healthcheck...
【容器化技术】Docker实战项目完全指南：多语言应用部署与优化
08-14
内容概要：本文档《docker实战.docx》详细介绍了Docker部署实战项目的全流程，涵盖Docker基础概念、实战项目案例、部署最佳实践、性能优化建议、安全性考虑以及监控和日志管理等方面。基础概念部分解释了Docker的...
kubectl 命令行更新项目版本号
March_A的博客
12-18 95
摘要：本文介绍了两种在Kubernetes中更新Deployment镜像版本的方法。第一种是使用kubectl set image命令直接指定新镜像地址，通过--record参数记录变更历史；第二种是登录master节点后使用kubectl edit手动修改Deployment配置。两种方法都会触发滚动更新，可以通过kubectl rollout status实时查看更新进度。文中以demo-app为例，详细说明了容器名与新镜像的对应关系以及命名空间(-n)参数的使用。
ELK + Redis Docker 企业级部署落地方案
赵玉的专栏
12-15 995
本文介绍了一个基于Docker的企业级ELK+Redis日志收集与分析系统部署方案。方案采用Docker Compose编排，包含Elasticsearch集群(3节点)、Logstash集群(2节点)、Kibana(2节点)和Redis主从复制(2节点)架构，并集成Prometheus、Grafana等监控工具。部署内容包括：1) 详细的环境准备和目录结构；2) Docker Compose编排文件；3) 各组件配置文件模板；4) 初始化、启动、健康检查等运维脚本；5) 监控告警配置；6) 备份恢复策略。
Colima 下 docker pull 失败自查流程
tfel-ypoc
12-17 386
使用 Colima 时 docker pull 失败故障排查
《8076 能通 9003 却超时？一次 Docker 容器跨网段排障小记》
weixin_41544125的博客
12-18 503
8076 通、9003 不通，说明网络链路（Docker 网桥 → 宿主机转发 → 物理交换机）没问题，只看到 SYN，没有 SYN-ACK → 包被目标主机丢弃。宿主机（192.168.100.8）本地执行。都 OK，排除 DNS 与三层路由大问题。RustFS 日志也不再出现。正常，所以服务确定在跑。
快速解决 Docker 环境中无法打开 gdb 调试窗口以及 tmux 中无法滚动页面内容和无法选中复制的问题
Welcome To Myon'Blog !
12-15 441
摘要：解决pwntools在Docker容器中无法启动GDB终端的问题，可通过配置context.terminal参数使用tmux分割窗口。推荐三种tmux配置方式：水平/垂直分割或新建窗口，并需预先安装tmux。同时需配置.tmux.conf文件启用鼠标支持和剪贴板功能，以方便窗口操作和内容复制。配置后需在tmux会话中执行脚本才能正常使用滚动和选择功能。
MySQL主从集群解析：从原理到Docker实战部署
2302_80105876的博客
12-13 2925
MySQL主从同步原理与应用实践 摘要：本文详细介绍了MySQL主从同步的技术原理与应用场景。主从同步通过binlog日志实现数据复制，支持Stat、Row、Mixed三种日志格式。文章分析了五种同步方式（全同步、异步、半同步、增强版同步和组复制）的特点与适用场景，对比了五种常见架构（一主一从、一主多从等）的优缺点。实战部分展示了通过Docker搭建主从集群的具体步骤，包括创建同步用户、配置主从关系和启动复制进程等关键操作。本文为数据库管理员提供了全面的主从同步技术参考，帮助根据业务需求选择合适的复制方案。
docker设置代理，通过代理服务器拉取镜像
最新发布
wuxingge的博客
12-19 70
【代码】docker设置代理，通过代理服务器拉取镜像。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

CarlowZJ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值