Linux 下高效开发环境搭建：VSCode Remote + 容器开发

LCG元2025-11-17 10:26

1. 环境准备与基础软件安装

1.1 系统要求检查

在开始之前，请确保您的 Linux 系统满足以下要求：

  • Ubuntu 18.04+、CentOS 7+ 或其他主流 Linux 发行版
  • 至少 4GB 内存（推荐 8GB 或以上）
  • 20GB 可用磁盘空间
  • 稳定的网络连接

1.2 安装 Docker

首先安装 Docker 作为容器化开发的基础平台。

创建安装脚本文件： install_docker.sh

bash 复制代码 
#!/bin/bash

# 卸载旧版本 Docker
sudo apt-get remove docker docker-engine docker.io containerd runc

# 更新软件包索引
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 组
sudo usermod -aG docker $USER

# 启动 Docker 服务
sudo systemctl enable docker
sudo systemctl start docker

# 验证安装
docker --version
echo "Docker 安装完成，请重新登录以使组权限生效"

运行安装脚本：

bash 复制代码 
chmod +x install_docker.sh
./install_docker.sh

1.3 安装 Visual Studio Code

创建安装脚本文件： install_vscode.sh

bash 复制代码 
#!/bin/bash

# 下载并安装 VS Code
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -o root -g root -m 644 packages.microsoft.gpg /etc/apt/trusted.gpg.d/
sudo sh -c 'echo "deb [arch=amd64,arm64,armhf signed-by=/etc/apt/trusted.gpg.d/packages.microsoft.gpg] https://packages.microsoft.com/repos/code stable main" > /etc/apt/sources.list.d/vscode.list'

# 更新并安装
sudo apt update
sudo apt install code

# 安装 Remote Development 扩展包
code --install-extension ms-vscode-remote.vscode-remote-extensionpack
code --install-extension ms-vscode-remote.remote-ssh
code --install-extension ms-vscode-remote.remote-containers
code --install-extension ms-vscode-remote.remote-ssh-edit

echo "VS Code 及远程开发扩展安装完成"

运行安装脚本：

bash 复制代码 
chmod +x install_vscode.sh
./install_vscode.sh

2. 配置开发容器环境

2.1 创建开发容器配置

创建目录结构：

bash 复制代码 
mkdir -p ~/dev-container/project
cd ~/dev-container

创建开发容器配置文件： devcontainer.json

json 复制代码 
{
    "name": "Python-DataScience-Dev-Container",
    "image": "mcr.microsoft.com/vscode/devcontainers/python:3.9",
    
    "settings": {
        "python.pythonPath": "/usr/local/bin/python",
        "python.linting.enabled": true,
        "python.linting.pylintEnabled": true,
        "python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
        "python.formatting.blackPath": "/usr/local/py-utils/bin/black",
        "python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
        "python.linting.banditPath": "/usr/local/py-utils/bin/bandit",
        "python.linting.flake8Path": "/usr/local/py-utils/bin/flake8",
        "python.linting.mypyPath": "/usr/local/py-utils/bin/mypy",
        "python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle",
        "python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle",
        "python.linting.pylintPath": "/usr/local/py-utils/bin/pylint"
    },
    
    "extensions": [
        "ms-python.python",
        "ms-python.vscode-pylance",
        "batisteo.vscode-django",
        "wholroyd.jinja",
        "formulahendry.auto-rename-tag",
        "esbenp.prettier-vscode",
        "ms-vscode.vscode-typescript-next",
        "bradlc.vscode-tailwindcss"
    ],
    
    "forwardPorts": [8000, 8080, 5000],
    
    "postCreateCommand": "pip install --upgrade pip && pip install -r requirements.txt",
    
    "remoteUser": "vscode",
    
    "features": {
        "git": "latest",
        "github-cli": "latest",
        "node": "latest",
        "python": {
            "version": "3.9",
            "installTools": true
        }
    }
}

创建项目依赖文件： requirements.txt

txt 复制代码 
numpy>=1.21.0
pandas>=1.3.0
matplotlib>=3.4.0
seaborn>=0.11.0
scikit-learn>=1.0.0
jupyter>=1.0.0
flask>=2.0.0
requests>=2.25.0
black>=21.0.0
flake8>=3.9.0
pytest>=6.0.0
python-dotenv>=0.19.0

2.2 创建自定义开发镜像

创建 Dockerfile： Dockerfile

dockerfile 复制代码 
# 使用官方 Python 运行时作为父镜像
FROM python:3.9-slim

# 设置环境变量
ENV PYTHONUNBUFFERED 1
ENV DEBIAN_FRONTEND=noninteractive

# 设置工作目录
WORKDIR /workspace

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    git \
    curl \
    wget \
    vim \
    htop \
    procps \
    build-essential \
    libssl-dev \
    zlib1g-dev \
    libbz2-dev \
    libreadline-dev \
    libsqlite3-dev \
    libffi-dev \
    && rm -rf /var/lib/apt/lists/*

# 创建非 root 用户
RUN useradd -m -s /bin/bash vscode && \
    usermod -aG sudo vscode && \
    echo "vscode ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers

# 切换用户
USER vscode

# 安装 pyenv
RUN curl https://pyenv.run | bash

# 设置 pyenv 环境变量
ENV HOME /home/vscode
ENV PYENV_ROOT $HOME/.pyenv
ENV PATH $PYENV_ROOT/shims:$PYENV_ROOT/bin:$PATH

# 安装 Python 版本管理工具
RUN echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc && \
    echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc && \
    echo 'eval "$(pyenv init -)"' >> ~/.bashrc

# 复制项目文件
COPY --chown=vscode:vscode requirements.txt .

# 安装 Python 依赖
RUN pip install --upgrade pip && \
    pip install -r requirements.txt

# 暴露端口
EXPOSE 8000 8080 5000

# 设置默认命令
CMD ["/bin/bash"]

创建镜像构建脚本： build_image.sh

bash 复制代码 
#!/bin/bash

# 设置变量
IMAGE_NAME="python-dev-container"
IMAGE_TAG="latest"

# 构建 Docker 镜像
docker build -t $IMAGE_NAME:$IMAGE_TAG .

# 验证镜像
docker images | grep $IMAGE_NAME

echo "开发镜像构建完成"

运行构建脚本：

bash 复制代码 
chmod +x build_image.sh
./build_image.sh

3. VSCode Remote-Containers 配置与使用

3.1 配置开发容器

在 VSCode 中配置开发容器：

  1. 打开命令面板 (Ctrl+Shift+P)
  2. 输入 "Remote-Containers: Open Folder in Container"
  3. 选择项目目录 ~/dev-container/project
  4. VSCode 将自动构建并连接到容器

创建容器启动配置： .devcontainer/devcontainer.json

json 复制代码 
{
    "name": "Custom Python Development Container",
    "build": {
        "dockerfile": "../Dockerfile",
        "context": ".."
    },
    
    "customizations": {
        "vscode": {
            "settings": {
                "terminal.integrated.shell.linux": "/bin/bash",
                "editor.fontSize": 14,
                "editor.lineHeight": 1.5,
                "editor.tabSize": 4,
                "editor.formatOnSave": true,
                "editor.codeActionsOnSave": {
                    "source.organizeImports": true
                },
                "python.defaultInterpreterPath": "/usr/local/bin/python",
                "python.languageServer": "Pylance",
                "python.analysis.autoImportCompletions": true,
                "python.analysis.typeCheckingMode": "basic"
            },
            
            "extensions": [
                "ms-python.python",
                "ms-python.vscode-pylance",
                "ms-python.vscode-python-debugger",
                "ms-toolsai.jupyter",
                "ms-toolsai.jupyter-keymap",
                "ms-toolsai.jupyter-renderers",
                "formulahendry.auto-rename-tag",
                "esbenp.prettier-vscode",
                "ms-vscode.vscode-typescript-next"
            ]
        }
    },
    
    "remoteUser": "vscode",
    
    "mounts": [
        "source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind",
        "source=${localEnv:HOME}/.ssh,target=/home/vscode/.ssh,type=bind"
    ],
    
    "runArgs": [
        "--cap-add=SYS_PTRACE",
        "--security-opt",
        "seccomp=unconfined"
    ],
    
    "postCreateCommand": "sudo chown vscode:vscode /home/vscode/.ssh && chmod 700 /home/vscode/.ssh && pip install --upgrade pip"
}

3.2 创建开发环境测试脚本

创建测试文件： test_environment.py

python 复制代码 
#!/usr/bin/env python3
"""
开发环境测试脚本
验证容器内开发环境是否正常配置
"""

import sys
import platform
import subprocess
import importlib.util


def check_python_version():
    """检查 Python 版本"""
    print("=" * 50)
    print("Python 环境检查")
    print("=" * 50)
    
    version = sys.version_info
    print(f"Python 版本: {sys.version}")
    print(f"架构: {platform.architecture()[0]}")
    print(f"操作系统: {platform.system()} {platform.release()}")
    
    if version.major == 3 and version.minor >= 8:
        print("✅ Python 版本符合要求")
        return True
    else:
        print("❌ Python 版本不符合要求")
        return False


def check_package_installation():
    """检查必要包的安装"""
    print("\n" + "=" * 50)
    print("包依赖检查")
    print("=" * 50)
    
    required_packages = [
        'numpy', 'pandas', 'matplotlib', 'seaborn',
        'sklearn', 'flask', 'jupyter', 'requests'
    ]
    
    all_installed = True
    for package in required_packages:
        spec = importlib.util.find_spec(package)
        if spec is not None:
            print(f"✅ {package} 已安装")
        else:
            print(f"❌ {package} 未安装")
            all_installed = False
    
    return all_installed


def check_system_tools():
    """检查系统工具"""
    print("\n" + "=" * 50)
    print("系统工具检查")
    print("=" * 50)
    
    tools = ['git', 'curl', 'vim']
    all_available = True
    
    for tool in tools:
        try:
            subprocess.run([tool, '--version'], 
                         capture_output=True, check=True)
            print(f"✅ {tool} 可用")
        except (subprocess.CalledProcessError, FileNotFoundError):
            print(f"❌ {tool} 不可用")
            all_available = False
    
    return all_available


def create_sample_app():
    """创建示例应用"""
    print("\n" + "=" * 50)
    print("创建示例 Flask 应用")
    print("=" * 50)
    
    sample_code = '''
from flask import Flask, jsonify
import numpy as np
import pandas as pd
from datetime import datetime

app = Flask(__name__)

@app.route('/')
def hello():
    return jsonify({
        "message": "开发环境运行正常!",
        "timestamp": datetime.now().isoformat(),
        "status": "success"
    })

@app.route('/data')
def data_demo():
    # 创建示例数据
    df = pd.DataFrame({
        'x': range(10),
        'y': np.random.randn(10)
    })
    return jsonify({
        "data": df.to_dict(orient='records'),
        "summary": {
            "mean": float(df['y'].mean()),
            "std": float(df['y'].std())
        }
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)
'''
    
    with open('app.py', 'w') as f:
        f.write(sample_code)
    
    print("✅ 示例应用创建完成")
    print("运行命令: python app.py")
    print("访问: http://localhost:5000")


def main():
    """主测试函数"""
    print("🚀 开始开发环境测试...")
    
    tests_passed = 0
    total_tests = 3
    
    # 运行测试
    if check_python_version():
        tests_passed += 1
    
    if check_package_installation():
        tests_passed += 1
    
    if check_system_tools():
        tests_passed += 1
    
    # 创建示例应用
    create_sample_app()
    
    # 输出总结
    print("\n" + "=" * 50)
    print("测试总结")
    print("=" * 50)
    print(f"通过测试: {tests_passed}/{total_tests}")
    
    if tests_passed == total_tests:
        print("🎉 所有测试通过！开发环境配置成功！")
        print("\n下一步:")
        print("1. 运行: python app.py")
        print("2. 在浏览器中打开 http://localhost:5000")
        print("3. 开始您的开发工作！")
    else:
        print("⚠️ 部分测试未通过，请检查配置")


if __name__ == "__main__":
    main()

创建开发环境管理脚本： manage_dev_env.sh

bash 复制代码 
#!/bin/bash

# 开发环境管理脚本

set -e

CONTAINER_NAME="python-dev-container"
PROJECT_DIR="/workspace"

case "$1" in
    start)
        echo "启动开发容器..."
        docker run -d \
            --name $CONTAINER_NAME \
            -p 8000:8000 \
            -p 5000:5000 \
            -p 8080:8080 \
            -v $(pwd):$PROJECT_DIR \
            -v /var/run/docker.sock:/var/run/docker.sock \
            python-dev-container:latest \
            tail -f /dev/null
        ;;
    
    stop)
        echo "停止开发容器..."
        docker stop $CONTAINER_NAME || true
        docker rm $CONTAINER_NAME || true
        ;;
    
    build)
        echo "重新构建开发镜像..."
        docker build -t python-dev-container:latest .
        ;;
    
    shell)
        echo "进入容器 shell..."
        docker exec -it $CONTAINER_NAME /bin/bash
        ;;
    
    logs)
        echo "查看容器日志..."
        docker logs $CONTAINER_NAME
        ;;
    
    test)
        echo "运行环境测试..."
        docker exec $CONTAINER_NAME python test_environment.py
        ;;
    
    *)
        echo "用法: $0 {start|stop|build|shell|logs|test}"
        echo ""
        echo "命令说明:"
        echo "  start   - 启动开发容器"
        echo "  stop    - 停止开发容器"
        echo "  build   - 重新构建镜像"
        echo "  shell   - 进入容器终端"
        echo "  logs    - 查看容器日志"
        echo "  test    - 运行环境测试"
        exit 1
esac

运行环境测试：

bash 复制代码 
chmod +x manage_dev_env.sh
./manage_dev_env.sh test

4. 开发环境工作流程

4.1 开发环境架构流程图

以下流程图展示了 VSCode Remote + 容器开发的完整架构：

graph TD A[开发者本地机器] --> B[VS Code IDE] B --> C[Remote-Containers 扩展] C --> D[Docker 守护进程] D --> E[开发容器] E --> F[应用程序代码] E --> G[开发工具链] E --> H[项目依赖] F --> I[代码编辑] G --> J[调试执行] H --> K[依赖管理] I --> L[实时同步] J --> M[端口转发] K --> N[环境隔离] L --> O[文件映射] M --> P[本地访问] N --> Q[一致性环境] O --> R[开发体验] P --> R Q --> R style A fill:#2c3e50,color:#ffffff style B fill:#3498db,color:#ffffff style C fill:#2980b9,color:#ffffff style D fill:#34495e,color:#ffffff style E fill:#16a085,color:#ffffff style R fill:#e74c3c,color:#ffffff style F fill:#27ae60,color:#ffffff style G fill:#f39c12,color:#ffffff style H fill:#8e44ad,color:#ffffff

4.2 创建开发工作流脚本

创建工作流自动化脚本： development_workflow.py

python 复制代码 
#!/usr/bin/env python3
"""
开发工作流自动化脚本
提供常用的开发任务自动化功能
"""

import os
import sys
import subprocess
import time
from pathlib import Path
import json


class DevelopmentWorkflow:
    def __init__(self, project_root="."):
        self.project_root = Path(project_root)
        self.setup_directories()
    
    def setup_directories(self):
        """创建标准项目目录结构"""
        directories = [
            'src',
            'tests',
            'docs',
            'data/raw',
            'data/processed',
            'notebooks',
            'scripts',
            'config',
            'logs'
        ]
        
        for directory in directories:
            dir_path = self.project_root / directory
            dir_path.mkdir(parents=True, exist_ok=True)
            print(f"✅ 确保目录存在: {directory}")
    
    def create_gitignore(self):
        """创建 .gitignore 文件"""
        gitignore_content = """
# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg

# Virtual environments
.env
.venv
env/
venv/
ENV/

# IDE
.vscode/
.idea/
*.swp
*.swo

# Data
data/raw/
data/processed/
*.csv
*.json
*.parquet

# Logs
logs/
*.log

# Jupyter
.ipynb_checkpoints
        """
        
        gitignore_path = self.project_root / '.gitignore'
        with open(gitignore_path, 'w') as f:
            f.write(gitignore_content)
        print("✅ .gitignore 文件创建完成")
    
    def setup_python_package(self):
        """设置 Python 包结构"""
        src_dir = self.project_root / 'src'
        init_file = src_dir / '__init__.py'
        
        with open(init_file, 'w') as f:
            f.write('''"""
开发项目主包
"""

__version__ = "0.1.0"
__author__ = "Your Name"
''')
        
        # 创建主模块
        main_module = src_dir / 'main.py'
        main_module_content = '''
def main():
    """主函数"""
    print("🚀 开发环境运行正常!")
    
    # 示例功能
    import numpy as np
    import pandas as pd
    
    # 创建示例数据
    data = {
        'feature1': np.random.randn(100),
        'feature2': np.random.randint(0, 10, 100),
        'target': np.random.choice([0, 1], 100)
    }
    
    df = pd.DataFrame(data)
    print(f"📊 示例数据框形状: {df.shape}")
    print(f"📈 数据摘要:")
    print(df.describe())
    
    return df

if __name__ == "__main__":
    main()
'''
        with open(main_module, 'w') as f:
            f.write(main_module_content)
        
        print("✅ Python 包结构设置完成")
    
    def create_requirements_dev(self):
        """创建开发依赖文件"""
        requirements_dev = """
# 开发依赖
black>=21.0.0
flake8>=3.9.0
pytest>=6.0.0
pytest-cov>=2.0.0
pre-commit>=2.0.0
jupyter>=1.0.0
ipython>=7.0.0

# 文档
sphinx>=4.0.0
sphinx-rtd-theme>=1.0.0
"""
        
        req_path = self.project_root / 'requirements-dev.txt'
        with open(req_path, 'w') as f:
            f.write(requirements_dev)
        print("✅ 开发依赖文件创建完成")
    
    def run_code_quality_checks(self):
        """运行代码质量检查"""
        print("🔍 运行代码质量检查...")
        
        try:
            # 运行 black 格式化检查
            subprocess.run([
                'black', '--check', 'src/', 'tests/'
            ], check=True)
            print("✅ black 格式化检查通过")
        except subprocess.CalledProcessError:
            print("⚠️ black 格式化检查未通过，运行 black 进行格式化")
            subprocess.run(['black', 'src/', 'tests/'])
        
        try:
            # 运行 flake8 代码风格检查
            subprocess.run([
                'flake8', 'src/', 'tests/'
            ], check=True)
            print("✅ flake8 代码风格检查通过")
        except subprocess.CalledProcessError:
            print("❌ flake8 代码风格检查发现问题")
        
        # 运行测试
        try:
            subprocess.run([
                'pytest', 'tests/', '-v', '--cov=src'
            ], check=True)
            print("✅ 测试通过")
        except subprocess.CalledProcessError:
            print("❌ 测试失败")
    
    def create_vscode_settings(self):
        """创建 VSCode 工作区设置"""
        vscode_dir = self.project_root / '.vscode'
        vscode_dir.mkdir(exist_ok=True)
        
        settings = {
            "python.defaultInterpreterPath": "/usr/local/bin/python",
            "python.linting.enabled": true,
            "python.linting.pylintEnabled": true,
            "python.linting.flake8Enabled": true,
            "python.formatting.provider": "black",
            "python.testing.pytestEnabled": true,
            "editor.formatOnSave": true,
            "editor.codeActionsOnSave": {
                "source.organizeImports": true
            },
            "files.exclude": {
                "**/__pycache__": true,
                "**/*.pyc": true
            }
        }
        
        settings_path = vscode_dir / 'settings.json'
        with open(settings_path, 'w') as f:
            json.dump(settings, f, indent=2)
        
        print("✅ VSCode 工作区设置创建完成")
    
    def setup_complete_workflow(self):
        """执行完整的工作流设置"""
        print("🚀 开始设置完整开发工作流...")
        
        self.setup_directories()
        self.create_gitignore()
        self.setup_python_package()
        self.create_requirements_dev()
        self.create_vscode_settings()
        
        print("\n🎉 开发工作流设置完成！")
        print("\n可用命令:")
        print("  python src/main.py      - 运行主程序")
        print("  pytest tests/           - 运行测试")
        print("  black src/ tests/       - 格式化代码")
        print("  flake8 src/ tests/      - 代码风格检查")


def main():
    """主函数"""
    if len(sys.argv) > 1:
        project_path = sys.argv[1]
    else:
        project_path = "."
    
    workflow = DevelopmentWorkflow(project_path)
    
    if len(sys.argv) > 2:
        command = sys.argv[2]
        if command == "setup":
            workflow.setup_complete_workflow()
        elif command == "quality":
            workflow.run_code_quality_checks()
        else:
            print("未知命令")
    else:
        workflow.setup_complete_workflow()


if __name__ == "__main__":
    main()

5. 高级配置与优化

5.1 多阶段开发容器配置

创建多阶段 Dockerfile： Dockerfile.multistage

dockerfile 复制代码 
# 多阶段构建开发环境 Dockerfile

# 第一阶段：构建阶段
FROM python:3.9-slim as builder

WORKDIR /build

# 安装构建依赖
RUN apt-get update && apt-get install -y \
    gcc \
    g++ \
    && rm -rf /var/lib/apt/lists/*

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

# 安装 Python 依赖到虚拟环境
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
RUN pip install --upgrade pip && \
    pip install -r requirements.txt

# 第二阶段：运行阶段
FROM python:3.9-slim as runtime

# 安装运行时依赖
RUN apt-get update && apt-get install -y \
    git \
    curl \
    vim \
    && rm -rf /var/lib/apt/lists/*

# 创建非 root 用户
RUN useradd -m -s /bin/bash vscode && \
    usermod -aG sudo vscode && \
    echo "vscode ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers

USER vscode
WORKDIR /workspace

# 从构建阶段复制虚拟环境
COPY --from=builder --chown=vscode:vscode /opt/venv /opt/venv

# 设置环境变量
ENV PATH="/opt/venv/bin:$PATH"
ENV PYTHONPATH="/workspace/src"

# 暴露端口
EXPOSE 8000 5000 8080

CMD ["/bin/bash"]

5.2 创建开发环境监控脚本

创建监控脚本： monitor_dev_env.py

python 复制代码 
#!/usr/bin/env python3
"""
开发环境监控脚本
监控容器资源使用情况和性能指标
"""

import psutil
import docker
import time
import json
from datetime import datetime
import logging
from pathlib import Path


class DevelopmentEnvironmentMonitor:
    def __init__(self, container_name=None):
        self.container_name = container_name
        self.docker_client = docker.from_env()
        self.setup_logging()
    
    def setup_logging(self):
        """设置日志"""
        log_dir = Path('logs')
        log_dir.mkdir(exist_ok=True)
        
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('logs/monitor.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def get_system_metrics(self):
        """获取系统指标"""
        return {
            'timestamp': datetime.now().isoformat(),
            'cpu_percent': psutil.cpu_percent(interval=1),
            'memory_percent': psutil.virtual_memory().percent,
            'disk_usage': psutil.disk_usage('/').percent,
            'active_processes': len(psutil.pids())
        }
    
    def get_container_metrics(self):
        """获取容器指标"""
        if not self.container_name:
            return None
        
        try:
            container = self.docker_client.containers.get(self.container_name)
            stats = container.stats(stream=False)
            
            # 解析容器统计信息
            cpu_stats = stats['cpu_stats']
            memory_stats = stats['memory_stats']
            
            return {
                'container_cpu_usage': cpu_stats.get('cpu_usage', {}).get('total_usage', 0),
                'container_memory_usage': memory_stats.get('usage', 0),
                'container_memory_limit': memory_stats.get('limit', 0),
                'container_network_io': stats.get('networks', {})
            }
        except docker.errors.NotFound:
            self.logger.warning(f"容器 {self.container_name} 未找到")
            return None
    
    def check_development_services(self):
        """检查开发服务状态"""
        services = {
            'jupyter': 8888,
            'flask_dev': 5000,
            'database': 5432
        }
        
        service_status = {}
        
        for service, port in services.items():
            try:
                import socket
                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                sock.settimeout(1)
                result = sock.connect_ex(('localhost', port))
                sock.close()
                service_status[service] = 'running' if result == 0 else 'stopped'
            except Exception as e:
                service_status[service] = f'error: {str(e)}'
        
        return service_status
    
    def generate_health_report(self):
        """生成健康报告"""
        system_metrics = self.get_system_metrics()
        container_metrics = self.get_container_metrics()
        service_status = self.check_development_services()
        
        report = {
            'system': system_metrics,
            'container': container_metrics,
            'services': service_status,
            'health_status': self.assess_health_status(system_metrics, service_status)
        }
        
        return report
    
    def assess_health_status(self, system_metrics, service_status):
        """评估健康状态"""
        warnings = []
        
        # 检查系统资源
        if system_metrics['cpu_percent'] > 80:
            warnings.append("CPU 使用率过高")
        
        if system_metrics['memory_percent'] > 85:
            warnings.append("内存使用率过高")
        
        if system_metrics['disk_usage'] > 90:
            warnings.append("磁盘空间不足")
        
        # 检查服务状态
        for service, status in service_status.items():
            if status != 'running':
                warnings.append(f"服务 {service} 未运行")
        
        if not warnings:
            return {
                'status': 'healthy',
                'message': '所有系统运行正常'
            }
        else:
            return {
                'status': 'degraded',
                'message': '; '.join(warnings)
            }
    
    def continuous_monitoring(self, interval=60):
        """持续监控"""
        self.logger.info("🚀 开始开发环境监控...")
        
        try:
            while True:
                report = self.generate_health_report()
                
                # 记录报告
                self.logger.info(f"系统状态: {report['health_status']['status']}")
                self.logger.info(f"CPU: {report['system']['cpu_percent']}%")
                self.logger.info(f"内存: {report['system']['memory_percent']}%")
                
                # 保存报告到文件
                report_file = Path('logs/health_report.json')
                with open(report_file, 'w') as f:
                    json.dump(report, f, indent=2)
                
                time.sleep(interval)
                
        except KeyboardInterrupt:
            self.logger.info("监控已停止")


def main():
    """主函数"""
    import argparse
    
    parser = argparse.ArgumentParser(description='开发环境监控工具')
    parser.add_argument('--container', help='容器名称')
    parser.add_argument('--interval', type=int, default=60, help='监控间隔（秒）')
    parser.add_argument('--once', action='store_true', help='单次运行')
    
    args = parser.parse_args()
    
    monitor = DevelopmentEnvironmentMonitor(args.container)
    
    if args.once:
        report = monitor.generate_health_report()
        print(json.dumps(report, indent=2))
    else:
        monitor.continuous_monitoring(args.interval)


if __name__ == "__main__":
    main()

6. 故障排除与优化

6.1 常见问题解决方案

创建故障排除脚本： troubleshooting_guide.py

python 复制代码 
#!/usr/bin/env python3
"""
开发环境故障排除指南
提供常见问题的检测和解决方案
"""

import subprocess
import sys
import os
from pathlib import Path


class DevelopmentTroubleshooter:
    def __init__(self):
        self.issues_found = []
        self.solutions_applied = []
    
    def check_docker_installation(self):
        """检查 Docker 安装"""
        print("🔍 检查 Docker 安装...")
        
        try:
            result = subprocess.run(
                ['docker', '--version'],
                capture_output=True,
                text=True,
                check=True
            )
            print(f"✅ Docker 已安装: {result.stdout.strip()}")
            return True
        except (subprocess.CalledProcessError, FileNotFoundError):
            print("❌ Docker 未安装或未在 PATH 中")
            self.issues_found.append("Docker 未正确安装")
            return False
    
    def check_docker_service(self):
        """检查 Docker 服务状态"""
        print("🔍 检查 Docker 服务状态...")
        
        try:
            result = subprocess.run(
                ['sudo', 'systemctl', 'is-active', 'docker'],
                capture_output=True,
                text=True,
                check=True
            )
            if result.stdout.strip() == 'active':
                print("✅ Docker 服务正在运行")
                return True
            else:
                print("❌ Docker 服务未运行")
                self.issues_found.append("Docker 服务未运行")
                return False
        except subprocess.CalledProcessError:
            print("❌ 无法检查 Docker 服务状态")
            return False
    
    def check_user_in_docker_group(self):
        """检查用户是否在 docker 组中"""
        print("🔍 检查用户组权限...")
        
        try:
            import grp
            current_user = os.getenv('USER')
            docker_group = grp.getgrnam('docker')
            
            if current_user in docker_group.gr_mem:
                print("✅ 用户在 docker 组中")
                return True
            else:
                print("❌ 用户不在 docker 组中，需要手动添加")
                self.issues_found.append("用户不在 docker 组中")
                return False
        except KeyError:
            print("❌ docker 组不存在")
            return False
    
    def check_vscode_extensions(self):
        """检查 VSCode 扩展"""
        print("🔍 检查 VSCode 远程扩展...")
        
        try:
            result = subprocess.run(
                ['code', '--list-extensions'],
                capture_output=True,
                text=True,
                check=True
            )
            
            required_extensions = [
                'ms-vscode-remote.vscode-remote-extensionpack',
                'ms-vscode-remote.remote-containers',
                'ms-python.python'
            ]
            
            installed_extensions = result.stdout.split('\n')
            
            for ext in required_extensions:
                if ext in installed_extensions:
                    print(f"✅ 扩展已安装: {ext}")
                else:
                    print(f"❌ 扩展未安装: {ext}")
                    self.issues_found.append(f"VSCode 扩展未安装: {ext}")
            
            return all(ext in installed_extensions for ext in required_extensions)
            
        except subprocess.CalledProcessError:
            print("❌ 无法获取 VSCode 扩展列表")
            return False
    
    def check_container_connectivity(self):
        """检查容器连接性"""
        print("🔍 检查容器连接性...")
        
        try:
            result = subprocess.run(
                ['docker', 'ps'],
                capture_output=True,
                text=True,
                check=True
            )
            
            if result.stdout.strip():
                print("✅ 可以连接到 Docker 守护进程")
                return True
            else:
                print("⚠️ 可以连接 Docker，但没有运行中的容器")
                return True
                
        except subprocess.CalledProcessError as e:
            print(f"❌ 无法连接到 Docker 守护进程: {e}")
            self.issues_found.append("无法连接到 Docker 守护进程")
            return False
    
    def apply_solutions(self):
        """应用解决方案"""
        print("\n🛠️ 应用解决方案...")
        
        for issue in self.issues_found:
            if "Docker 服务未运行" in issue:
                print("启动 Docker 服务...")
                try:
                    subprocess.run(['sudo', 'systemctl', 'start', 'docker'], check=True)
                    subprocess.run(['sudo', 'systemctl', 'enable', 'docker'], check=True)
                    self.solutions_applied.append("Docker 服务已启动并启用")
                except subprocess.CalledProcessError as e:
                    print(f"❌ 启动 Docker 服务失败: {e}")
            
            if "用户不在 docker 组中" in issue:
                print("将用户添加到 docker 组...")
                current_user = os.getenv('USER')
                try:
                    subprocess.run(['sudo', 'usermod', '-aG', 'docker', current_user], check=True)
                    self.solutions_applied.append(f"用户 {current_user} 已添加到 docker 组")
                    print("✅ 用户已添加到 docker 组，请重新登录使更改生效")
                except subprocess.CalledProcessError as e:
                    print(f"❌ 添加用户到 docker 组失败: {e}")
    
    def generate_report(self):
        """生成故障排除报告"""
        print("\n" + "="*50)
        print("故障排除报告")
        print("="*50)
        
        if not self.issues_found:
            print("🎉 未发现问题！开发环境配置正确。")
        else:
            print(f"发现 {len(self.issues_found)} 个问题:")
            for issue in self.issues_found:
                print(f"  • {issue}")
            
            if self.solutions_applied:
                print(f"\n已应用 {len(self.solutions_applied)} 个解决方案:")
                for solution in self.solutions_applied:
                    print(f"  ✅ {solution}")
            
            print("\n如果问题仍然存在，请尝试:")
            print("  1. 重启系统")
            print("  2. 检查 Docker 日志: sudo journalctl -u docker")
            print("  3. 重新安装 Docker")
    
    def run_full_check(self):
        """运行完整检查"""
        print("🚀 开始开发环境故障排除...\n")
        
        self.check_docker_installation()
        self.check_docker_service()
        self.check_user_in_docker_group()
        self.check_vscode_extensions()
        self.check_container_connectivity()
        
        self.apply_solutions()
        self.generate_report()


def main():
    """主函数"""
    troubleshooter = DevelopmentTroubleshooter()
    troubleshooter.run_full_check()


if __name__ == "__main__":
    main()

6.2 性能优化配置

创建性能优化脚本： optimize_performance.py

python 复制代码 
#!/usr/bin/env python3
"""
开发环境性能优化配置
优化容器和 VSCode 性能
"""

import json
import subprocess
from pathlib import Path


class PerformanceOptimizer:
    def __init__(self):
        self.optimizations_applied = []
    
    def optimize_docker_daemon(self):
        """优化 Docker 守护进程配置"""
        print("🔧 优化 Docker 守护进程配置...")
        
        docker_daemon_config = {
            "log-driver": "json-file",
            "log-opts": {
                "max-size": "10m",
                "max-file": "3"
            },
            "storage-driver": "overlay2",
            "default-ulimits": {
                "nofile": {
                    "Name": "nofile",
                    "Hard": 65536,
                    "Soft": 65536
                }
            }
        }
        
        config_path = Path('/etc/docker/daemon.json')
        
        try:
            # 备份现有配置
            if config_path.exists():
                backup_path = config_path.with_suffix('.json.backup')
                config_path.rename(backup_path)
                print(f"✅ 现有配置已备份到: {backup_path}")
            
            # 写入新配置
            with open(config_path, 'w') as f:
                json.dump(docker_daemon_config, f, indent=2)
            
            # 重启 Docker 服务
            subprocess.run(['sudo', 'systemctl', 'restart', 'docker'], check=True)
            
            self.optimizations_applied.append("Docker 守护进程配置优化")
            print("✅ Docker 守护进程配置已优化")
            
        except Exception as e:
            print(f"❌ Docker 配置优化失败: {e}")
    
    def optimize_vscode_settings(self):
        """优化 VSCode 设置"""
        print("🔧 优化 VSCode 性能设置...")
        
        vscode_settings = {
            "editor.minimap.enabled": False,
            "extensions.autoUpdate": False,
            "git.enableSmartCommit": true,
            "git.autofetch": true,
            "files.autoSave": "afterDelay",
            "files.autoSaveDelay": 1000,
            "telemetry.enableCrashReporter": false,
            "telemetry.enableTelemetry": false,
            "python.terminal.activateEnvironment": false,
            "remote.autoForwardPorts": false
        }
        
        # 用户设置路径
        vscode_user_dir = Path.home() / '.config' / 'Code' / 'User'
        vscode_user_dir.mkdir(parents=True, exist_ok=True)
        
        settings_path = vscode_user_dir / 'settings.json'
        
        try:
            # 读取现有设置
            existing_settings = {}
            if settings_path.exists():
                with open(settings_path, 'r') as f:
                    existing_settings = json.load(f)
            
            # 合并设置
            optimized_settings = {**existing_settings, **vscode_settings}
            
            # 写入优化后的设置
            with open(settings_path, 'w') as f:
                json.dump(optimized_settings, f, indent=2)
            
            self.optimizations_applied.append("VSCode 性能设置优化")
            print("✅ VSCode 性能设置已优化")
            
        except Exception as e:
            print(f"❌ VSCode 设置优化失败: {e}")
    
    def optimize_system_limits(self):
        """优化系统限制"""
        print("🔧 优化系统限制...")
        
        limits_config = """
# 开发环境优化配置
* soft nofile 65536
* hard nofile 65536
* soft nproc 65536
* hard nproc 65536
"""
        
        try:
            limits_path = Path('/etc/security/limits.d/99-dev-environment.conf')
            
            with open(limits_path, 'w') as f:
                f.write(limits_config)
            
            self.optimizations_applied.append("系统文件描述符限制优化")
            print("✅ 系统限制已优化")
            
        except Exception as e:
            print(f"❌ 系统限制优化失败: {e}")
    
    def cleanup_docker_resources(self):
        """清理 Docker 资源"""
        print("🧹 清理 Docker 资源...")
        
        try:
            # 停止所有容器
            subprocess.run(['docker', 'stop', '$(docker ps -aq)'], 
                         capture_output=True, shell=True)
            
            # 删除所有停止的容器
            subprocess.run(['docker', 'rm', '$(docker ps -aq)'], 
                         capture_output=True, shell=True)
            
            # 删除悬空镜像
            subprocess.run(['docker', 'image', 'prune', '-f'], check=True)
            
            # 删除构建缓存
            subprocess.run(['docker', 'builder', 'prune', '-f'], check=True)
            
            self.optimizations_applied.append("Docker 资源清理")
            print("✅ Docker 资源已清理")
            
        except Exception as e:
            print(f"❌ Docker 资源清理失败: {e}")
    
    def generate_optimization_report(self):
        """生成优化报告"""
        print("\n" + "="*50)
        print("性能优化报告")
        print("="*50)
        
        if self.optimizations_applied:
            print(f"✅ 已应用 {len(self.optimizations_applied)} 个优化:")
            for optimization in self.optimizations_applied:
                print(f"  • {optimization}")
            
            print("\n建议下一步:")
            print("  1. 重启系统以使所有优化生效")
            print("  2. 监控系统性能")
            print("  3. 根据需要进行进一步调整")
        else:
            print("⚠️ 未应用任何优化")
    
    def run_full_optimization(self):
        """运行完整优化"""
        print("🚀 开始开发环境性能优化...\n")
        
        self.optimize_docker_daemon()
        self.optimize_vscode_settings()
        self.optimize_system_limits()
        self.cleanup_docker_resources()
        
        self.generate_optimization_report()


def main():
    """主函数"""
    optimizer = PerformanceOptimizer()
    optimizer.run_full_optimization()


if __name__ == "__main__":
    main()

7. 总结与最佳实践

通过以上完整的配置和优化，您已经成功搭建了一个高效、可靠的 Linux 开发环境。这个环境具有以下优势：

7.1 环境一致性

  • 容器化确保所有开发者使用相同的环境
  • 版本控制开发配置
  • 快速环境重建能力

7.2 开发效率

  • VSCode 提供完整的 IDE 功能
  • 实时代码同步和调试
  • 集成的终端和版本控制

7.3 可维护性

  • 配置即代码
  • 自动化脚本减少手动操作
  • 监控和故障排除工具

7.4 扩展性

  • 支持多种编程语言和框架
  • 易于添加新工具和服务
  • 可复用的开发环境配置

这个开发环境配置为团队协作和项目开发提供了坚实的基础，确保开发过程的顺畅和高效。

相关推荐
哈里谢顿3 小时前
深入理解 Linux 系统 PATH 目录：从理论到实践
linux
刘延林.3 小时前
树莓派 5 上 Ubuntu 24.04 LTS 自带 RDP 远程桌面重启密码就变
linux·运维·ubuntu
我不是醉忧3 小时前
RedHat系统搭建DNS主从服务器
linux·运维·服务器
大神的风范3 小时前
linux之ubuntu qt界面开发开发点菜系统
linux·qt·ubuntu
正在努力的小河3 小时前
Linux SPI 驱动实验
linux·运维·服务器
adnyting3 小时前
【Linux日新月异(九)】CentOS 7其他常用命令大全：系统操作与管理必备技巧
linux·运维·centos
偶像你挑的噻4 小时前
3-Linux驱动开发-简单内核模块代码详解
linux·驱动开发·stm32·嵌入式硬件
赖small强4 小时前
【Linux驱动开发】 Linux字符设备开发详细指南
linux·驱动开发·字符设备
p66666666684 小时前
【☀Linux驱动开发笔记☀】linux下led驱动（非设备树）_03
linux·驱动开发·笔记·嵌入式硬件·学习
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）05Linux下V2Ray安装配置指南06《大数据技术原理与应用》实验报告三 熟悉HBase常用操作07综合整理：pdf预览显示：你尝试预览的文件可能对你的计算机有害。如果你信任此文件以及其来源，请打开此文件以看其内容，如何解决以正常预览文件08jdk21下载、安装（Windows、Linux、macOS）092025 最新教程：注册并切换到美区 Apple ID10智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践