Python项目部署到2核2G云服务器时，如何合理限制内存和CPU使用？

在2核2G的云服务器上部署Python项目，资源非常有限，必须采取多层次、组合式的限制策略。以下是从应用层到系统层的完整方案：

一、核心原则

1. 优先限制内存：2GB RAM极易被OOM（Out of Memory）杀死进程
2. CPU限制次之：2核可承受一定并发，但需防止单进程占满CPU
3. 预留系统开销：至少保留500MB-1GB给操作系统和后台服务

二、应用层限制（推荐首选）

1. Python解释器层面

# 使用 resource 模块限制当前进程内存（Linux/macOS）
import resource
import sys

def limit_memory(max_mb=800):
    """限制进程最大内存使用量"""
    soft, hard = resource.getrlimit(resource.RLIMIT_AS)
    resource.setrlimit(
        resource.RLIMIT_AS,
        (max_mb * 1024 * 1024, hard)
    )
    print(f"Memory limit set to {max_mb}MB")

if __name__ == "__main__":
    limit_memory(800)  # 限制为800MB

⚠️ RLIMIT_AS 是虚拟内存限制，实际物理内存可能略低。

2. 使用 cgroups（Linux内核级，最可靠）

# 创建cgroup限制
sudo cgcreate -g memory,pids:/myapp
echo "800M" | sudo tee /sys/fs/cgroup/memory/myapp/memory.limit_in_bytes
echo "2" | sudo tee /sys/fs/cgroup/pids/myapp/pids.max

启动应用时加入cgroup：

sudo cgexec -g memory,pids:/myapp python app.py

3. Docker容器限制（推荐生产环境）

# docker-compose.yml
version: '3.8'
services:
  web:
    image: my-python-app
    deploy:
      resources:
        limits:
          cpus: '1.5'       # 最多使用1.5个CPU核心
          memory: 800M       # 最多800MB内存
        reservations:
          cpus: '0.5'       # 保证最少0.5个核心
          memory: 256M      # 保证最少256MB内存

或直接docker run：

docker run -d 
  --cpus="1.5" 
  --memory="800m" 
  --memory-swap="800m" 
  --pids-limit=50 
  my-python-app

4. Nginx + Gunicorn/uWSGI 架构中的限制

Gunicorn配置：

# gunicorn.conf.py
workers = 2           # 2核建议2-3个工作进程
worker_class = "gevent"  # 协程模型更省内存
threads = 4            # 每个worker线程数
worker_connections = 1000

# 内存监控与优雅重启
max_requests = 1000     # 每个worker处理1000请求后重启，防止内存泄漏
max_requests_jitter = 50

# 可选：启用内存限制插件
# pip install gunicorn-memory-limit

uWSGI配置：

[uwsgi]
processes = 2
threads = 4
master = true
max-requests = 1000
harakiri = 30           # 单个请求超时30秒
limit-as = 800          # 限制虚拟内存800MB
vacuum = true
die-on-term = true

三、框架/库层面优化

1. 数据库连接池限制

# SQLAlchemy示例
engine = create_engine(
    DATABASE_URL,
    pool_size=5,           # 最大连接数
    max_overflow=2,        # 超出pool_size后的额外连接
    pool_recycle=3600,     # 连接回收时间
    pool_pre_ping=True     # 健康检查
)

2. 缓存内存控制

# Redis客户端限制
redis_client = redis.Redis(
    host='localhost',
    max_connections=10,    # 限制连接数
    socket_timeout=5,
    retry_on_timeout=True
)

# 或使用Redis服务器端限制
# redis.conf中设置：
# maxmemory 256mb
# maxmemory-policy allkeys-lru

3. 避免内存泄漏

• 使用生成器而非列表推导式处理大数据
• 及时关闭文件句柄和网络连接
• 定期重启worker进程（通过max_requests实现）

四、系统层保护

1. OOM Killer保护

# 查看当前内存使用
free -h
top

# 设置swappiness（降低swap使用倾向）
sudo sysctl vm.swappiness=10

# 永久生效
echo "vm.swappiness=10" | sudo tee -a /etc/sysctl.conf

2. 监控与告警

# 安装htop实时监控
sudo apt install htop

# 使用prometheus+node_exporter监控
# 或简单脚本监控内存
while true; do
    MEM=$(free -m | awk '/^Mem:/ {print $3}')
    if [ $MEM -gt 750 ]; then
        echo "$(date): High memory usage: ${MEM}MB" >> /var/log/memory_monitor.log
    fi
    sleep 60
done &

3. 自动重启机制

# systemd服务文件 /etc/systemd/system/myapp.service
[Unit]
Description=My Python App
After=network.target

[Service]
Type=simple
User=www-data
WorkingDirectory=/opt/myapp
ExecStart=/usr/bin/python3 /opt/myapp/app.py
Restart=always
RestartSec=10
# 内存超限时重启
SuccessExitStatus=143
TimeoutStopSec=10

[Install]
WantedBy=multi-user.target

配合LimitAS使用systemd限制：

[Service]
LimitAS=800M
LimitRSS=600M

五、推荐架构组合

┌─────────────────────────────────────────────┐
│           Nginx (反向X_X)                   │
│         静态文件服务 + 负载均衡              │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│         Gunicorn / uWSGI                     │
│   • workers=2, threads=4                    │
│   • max_requests=1000 (防内存泄漏)          │
│   • worker_class=gevent (高并发)            │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│         Python Application                  │
│   • 应用内内存限制 (resource模块)           │
│   • 数据库连接池限制                        │
│   • 缓存大小限制                            │
└──────────────────┬──────────────────────────┘
                   │
┌──────────────────▼──────────────────────────┐
│         Database (SQLite/MySQL)             │
│   • SQLite适合小数据量                      │
│   • MySQL需限制连接数和缓冲池               │
└─────────────────────────────────────────────┘

六、关键参数总结表

七、测试与验证

# 压力测试脚本
import requests
import time

def stress_test(url, num_requests=1000):
    start = time.time()
    errors = 0
    for i in range(num_requests):
        try:
            resp = requests.get(url)
            if resp.status_code != 200:
                errors += 1
        except Exception as e:
            errors += 1
    elapsed = time.time() - start
    print(f"完成 {num_requests} 请求，耗时 {elapsed:.2f}s")
    print(f"错误率: {errors/num_requests*100:.2f}%")
    print(f"QPS: {num_requests/elapsed:.2f}")

stress_test("http://localhost:8000/api/test")

同时监控资源：

# 实时监控
watch -n 1 'free -h && ps aux --sort=-%mem | head -10'

八、常见陷阱与解决方案

通过以上多层限制策略，可以在2核2G服务器上稳定运行大多数Python Web应用。关键是不要依赖单一限制手段，而是从应用、容器、系统三个层面协同控制。