25.5 智能部署
智能部署概述
Claude Code 可以自动化部署流程、优化部署配置、监控部署状态，并提供部署优化建议。通过智能部署功能，开发者可以快速、安全地将应用部署到生产环境。
自动化部署
1. Docker 部署
示例：生成 Docker 部署配置
用户请求： "为这个 Flask 应用生成 Docker 部署配置"
Claude Code 生成的配置：
python
## Dockerfile
dockerfile
````dockerfile
```python
FROM python:3.11-slim
WORKDIR /app
# 安装系统依赖
RUN apt-get update && apt-get install -y \
gcc \
&& rm -rf /var/lib/apt/lists/*
# 复制依赖文件
COPY requirements.txt .
# 安装 Python 依赖
RUN pip install --no-cache-dir -r requirements.txt
# 复制应用代码
COPY . .
# 创建非 root 用户
RUN useradd -m appuser && chown -R appuser:appuser /app
USER appuser
# 暴露端口
EXPOSE 5000
# 健康检查
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
CMD curl -f http://localhost:5000/health || exit 1
# 启动应用
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "--workers", "4", "app:app"]
```## docker-compose.yml
```
yaml
version: '3.8'
services:
web:
build: .
ports:
- "5000:5000"
environment:
- FLASK_ENV=production
- DATABASE_URL=postgresql://user:password@db:5432/mydb
- REDIS_URL=redis://redis:6379/0
- SECRET_KEY=${SECRET_KEY}
depends_on:
- db
- redis
volumes:
- ./logs:/app/logs
restart: unless-stopped
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:5000/health"]
interval: 30s
timeout: 10s
retries: 3
start_period: 40s
db:
image: postgres:15-alpine
environment:
- POSTGRES_USER=user
- POSTGRES_PASSWORD=password
- POSTGRES_DB=mydb
volumes:
- postgres_data:/var/lib/postgresql/data
restart: unless-stopped
healthcheck:
test: ["CMD-SHELL", "pg_isready -U user -d mydb"]
interval: 10s
timeout: 5s
retries: 5
redis:
image: redis:7-alpine
volumes:
- redis_data:/data
restart: unless-stopped
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 10s
timeout: 5s
retries: 5
nginx:
image: nginx:alpine
ports:
- "80:80"
- "443:443"
volumes:
- ./nginx.conf:/etc/nginx/nginx.conf:ro
- ./ssl:/etc/nginx/ssl:ro
depends_on:
- web
restart: unless-stopped
volumes:
postgres_data:
redis_data:
## nginx.conf
````nginx
````nginx
events {
worker_connections 1024;
}
http {
upstream web {
least_conn;
server web:5000;
}
# 限流配置
limit_req_zone $binary_remote_addr zone=api_limit:10m rate=10r/s;
server {
listen 80;
server_name example.com;
# 重定向到 HTTPS
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
server_name example.com;
ssl_certificate /etc/nginx/ssl/cert.pem;
ssl_certificate_key /etc/nginx/ssl/key.pem;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers HIGH:!aNULL:!MD5;
# 日志配置
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log;
# 静态文件缓存
location /static/ {
alias /app/static/;
expires 30d;
add_header Cache-Control "public, immutable";
}
# API 限流
location /api/ {
limit_req zone=api_limit burst=20 nodelay;
proxy_pass http://web;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
# 健康检查
location /health {
proxy_pass http://web/health;
access_log off;
}
# 默认代理
location / {
proxy_pass http://web;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
}
```## .dockerignore
```
__pycache__
> *.pyc
> *.pyo
> *.pyd
.Python
env/
venv/
ENV/
.venv
.git/
.gitignore
README.md
Dockerfile
docker-compose.yml
nginx.conf
.env
> *.log
tests/
.pytest_cache/
.coverage
htmlcov/
## 部署脚本
```
``bash
`````bash
#!/bin/bash
# deploy.sh - 部署脚本
set -e
echo "开始部署..."
# 拉取最新代码
git pull origin main
# 构建镜像
docker-compose build
# 停止旧容器
docker-compose down
# 启动新容器
docker-compose up -d
# 等待服务启动
sleep 10
# 健康检查
if curl -f http://localhost:5000/health; then
echo "部署成功！"
else
echo "部署失败！"
docker-compose logs
exit 1
fi
# 清理旧镜像
docker image prune -f
echo "部署完成！"
## 回滚脚本
```bash
bash
#!/bin/bash
# rollback.sh - 回滚脚本
set -e
echo "开始回滚..."
# 停止当前容器
docker-compose down
# 拉取上一个版本
git checkout HEAD~1
# 启动旧版本
docker-compose up -d
# 等待服务启动
sleep 10
# 健康检查
if curl -f http://localhost:5000/health; then
echo "回滚成功！"
else
echo "回滚失败！"
docker-compose logs
exit 1
fi
echo "回滚完成！"
### 2. Kubernetes 部署
```python
python
# 示例：生成 Kubernetes 部署配置
用户请求：
"为这个应用生成 Kubernetes 部署配置"
Claude Code 生成的配置：
## deployment.yaml
```yaml
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: web-app
labels:
app: web-app
spec:
replicas: 3
selector:
matchLabels:
app: web-app
template:
metadata:
labels:
app: web-app
spec:
containers:
- name: web-app
image: myregistry.com/web-app:latest
ports:
- containerPort: 5000
env:
- name: FLASK_ENV
value: "production"
- name: DATABASE_URL
valueFrom:
secretKeyRef:
name: app-secrets
key: database-url
- name: SECRET_KEY
valueFrom:
secretKeyRef:
name: app-secrets
key: secret-key
- name: REDIS_URL
value: "redis://redis-service:6379/0"
resources:
requests:
memory: "256Mi"
cpu: "250m"
limits:
memory: "512Mi"
cpu: "500m"
livenessProbe:
httpGet:
path: /health
port: 5000
initialDelaySeconds: 30
periodSeconds: 10
timeoutSeconds: 5
failureThreshold: 3
readinessProbe:
httpGet:
path: /health
port: 5000
initialDelaySeconds: 10
periodSeconds: 5
timeoutSeconds: 3
failureThreshold: 3
---
apiVersion: v1
kind: Service
metadata:
name: web-app-service
spec:
selector:
app: web-app
ports:
- protocol: TCP
port: 80
targetPort: 5000
type: ClusterIP
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: web-app-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: web-app
minReplicas: 3
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
- type: Resource
resource:
name: memory
target:
type: Utilization
averageUtilization: 80
## ingress.yaml
```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: web-app-ingress
annotations:
cert-manager.io/cluster-issuer: "letsencrypt-prod"
nginx.ingress.kubernetes.io/ssl-redirect: "true"
nginx.ingress.kubernetes.io/rate-limit: "100"
spec:
ingressClassName: nginx
tls:
- hosts:
- example.com
secretName: web-app-tls
rules:
- host: example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: web-app-service
port:
number: 80
## configmap.yaml
```yaml
yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: app-config
data:
FLASK_ENV: "production"
LOG_LEVEL: "info"
MAX_WORKERS: "4"
## secret.yaml
```yaml
apiVersion: v1
kind: Secret
metadata:
name: app-secrets
type: Opaque
stringData:
database-url: "postgresql://user:password@postgres-service:5432/mydb"
secret-key: "your-secret-key-here"
## postgres-deployment.yaml
```yaml
yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: postgres
spec:
serviceName: postgres-service
replicas: 1
selector:
matchLabels:
app: postgres
template:
metadata:
labels:
app: postgres
spec:
containers:
- name: postgres
image: postgres:15-alpine
ports:
- containerPort: 5432
env:
- name: POSTGRES_USER
valueFrom:
secretKeyRef:
name: app-secrets
key: postgres-user
- name: POSTGRES_PASSWORD
valueFrom:
secretKeyRef:
name: app-secrets
key: postgres-password
- name: POSTGRES_DB
value: mydb
volumeMounts:
- name: postgres-storage
mountPath: /var/lib/postgresql/data
resources:
requests:
memory: "512Mi"
cpu: "500m"
limits:
memory: "1Gi"
cpu: "1000m"
volumeClaimTemplates:
- metadata:
name: postgres-storage
spec:
accessModes: ["ReadWriteOnce"]
resources:
requests:
storage: 10Gi
---
apiVersion: v1
kind: Service
metadata:
name: postgres-service
spec:
selector:
app: postgres
ports:
- port: 5432
targetPort: 5432
clusterIP: None
## redis-deployment.yaml
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: redis
spec:
replicas: 1
selector:
matchLabels:
app: redis
template:
metadata:
labels:
app: redis
spec:
containers:
- name: redis
image: redis:7-alpine
ports:
- containerPort: 6379
resources:
requests:
memory: "128Mi"
cpu: "100m"
limits:
memory: "256Mi"
cpu: "200m"
> ---
apiVersion: v1
kind: Service
metadata:
name: redis-service
spec:
selector:
app: redis
ports:
- port: 6379
targetPort: 6379
clusterIP: None
## 部署脚本
```bash
bash
#!/bin/bash
# k8s-deploy.sh - Kubernetes 部署脚本
set -e
NAMESPACE="production"
echo "开始部署到 Kubernetes..."
# 创建命名空间
kubectl create namespace $NAMESPACE --dry-run=client -o yaml | kubectl apply -f -
# 应用配置
kubectl apply -f configmap.yaml -n $NAMESPACE
kubectl apply -f secret.yaml -n $NAMESPACE
# 部署数据库
kubectl apply -f postgres-deployment.yaml -n $NAMESPACE
kubectl apply -f redis-deployment.yaml -n $NAMESPACE
# 等待数据库就绪
kubectl wait --for=condition=ready pod -l app=postgres -n $NAMESPACE --timeout=300s
kubectl wait --for=condition=ready pod -l app=redis -n $NAMESPACE --timeout=300s
# 部署应用
kubectl apply -f deployment.yaml -n $NAMESPACE
kubectl apply -f ingress.yaml -n $NAMESPACE
# 等待应用就绪
kubectl wait --for=condition=ready pod -l app=web-app -n $NAMESPACE --timeout=300s
echo "部署成功！"
## 部署监控
### 1. 健康检查
```python
python
# 示例：实现健康检查
用户请求：
"为应用实现健康检查"
Claude Code 生成的代码：
```python
```python
from flask import Flask, jsonify
import psutil
import time
from datetime import datetime
app = Flask(__name__)
# 健康状态
health_status = {
'status': 'healthy',
'last_check': datetime.utcnow(),
'checks': {}
}
@app.route('/health')
def health_check():
"""健康检查端点"""
checks = {
'database': check_database(),
'redis': check_redis(),
'disk_space': check_disk_space(),
'memory': check_memory()
}
all_healthy = all(check['status'] == 'ok' for check in checks.values())
health_status['status'] = 'healthy' if all_healthy else 'unhealthy'
health_status['last_check'] = datetime.utcnow()
health_status['checks'] = checks
status_code = 200 if all_healthy else 503
return jsonify(health_status), status_code
@app.route('/health/ready')
def readiness_check():
"""就绪检查"""
try:
check_database()
check_redis()
return jsonify({'status': 'ready'}), 200
except Exception as e:
return jsonify({'status': 'not ready', 'error': str(e)}), 503
@app.route('/health/live')
def liveness_check():
"""存活检查"""
return jsonify({'status': 'alive', 'timestamp': datetime.utcnow().isoformat()}), 200
def check_database():
"""检查数据库连接"""
try:
from app import db
db.session.execute('SELECT 1')
return {'status': 'ok', 'message': 'Database connection successful'}
except Exception as e:
return {'status': 'error', 'message': str(e)}
def check_redis():
"""检查 Redis 连接"""
try:
from app import redis
redis.ping()
return {'status': 'ok', 'message': 'Redis connection successful'}
except Exception as e:
return {'status': 'error', 'message': str(e)}
def check_disk_space():
"""检查磁盘空间"""
disk = psutil.disk_usage('/')
free_percent = (disk.free / disk.total) * 100
if free_percent < 10:
return {
'status': 'error',
'message': f'Low disk space: {free_percent:.1f}% free'
}
return {
'status': 'ok',
'message': f'Disk space: {free_percent:.1f}% free'
}
def check_memory():
"""检查内存使用"""
memory = psutil.virtual_memory()
used_percent = memory.percent
if used_percent > 90:
return {
'status': 'error',
'message': f'High memory usage: {used_percent:.1f}%'
}
return {
'status': 'ok',
'message': f'Memory usage: {used_percent:.1f}%'
}
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)
### 2. 日志监控
```python
# 示例：实现日志监控
用户请求：
"为应用实现日志监控"
Claude Code 生成的代码：
```python
```python
import logging
from logging.handlers import RotatingFileHandler
import json
from datetime import datetime
from flask import request, g
class JSONFormatter(logging.Formatter):
"""JSON 日志格式化器"""
def format(self, record):
log_data = {
'timestamp': datetime.utcnow().isoformat(),
'level': record.levelname,
'message': record.getMessage(),
'logger': record.name,
'module': record.module,
'function': record.funcName,
'line': record.lineno
}
if hasattr(request, 'path'):
log_data['request'] = {
'method': request.method,
'path': request.path,
'ip': request.remote_addr
}
if hasattr(g, 'user_id'):
log_data['user_id'] = g.user_id
if record.exc_info:
log_data['exception'] = self.formatException(record.exc_info)
return json.dumps(log_data)
def setup_logging(app):
"""设置日志"""
# 创建日志目录
import os
log_dir = 'logs'
os.makedirs(log_dir, exist_ok=True)
# 应用日志
app_handler = RotatingFileHandler(
'logs/app.log',
maxBytes=10485760, # 10MB
backupCount=10
)
app_handler.setFormatter(JSONFormatter())
app_handler.setLevel(logging.INFO)
# 错误日志
error_handler = RotatingFileHandler(
'logs/error.log',
maxBytes=10485760,
backupCount=10
)
error_handler.setFormatter(JSONFormatter())
error_handler.setLevel(logging.ERROR)
# 访问日志
access_handler = RotatingFileHandler(
'logs/access.log',
maxBytes=10485760,
backupCount=10
)
access_handler.setFormatter(JSONFormatter())
access_handler.setLevel(logging.INFO)
# 配置日志
app.logger.addHandler(app_handler)
app.logger.addHandler(error_handler)
app.logger.setLevel(logging.INFO)
# 访问日志中间件
@app.before_request
def log_request():
g.start_time = time.time()
@app.after_request
def log_response(response):
if hasattr(g, 'start_time'):
duration = time.time() - g.start_time
app.logger.info(
f"Request completed",
extra={
'status_code': response.status_code,
'duration': duration
}
)
return response
return app
## 部署优化
### 1. 性能优化
# 示例：优化部署性能
用户请求：
"优化应用部署性能"
Claude Code 生成的优化建议：
## 部署性能优化
### 1. 容器优化
#### Dockerfile 优化
````dockerfile
`dockerfile
# 多阶段构建
FROM python:3.11-slim as builder
WORKDIR /app
# 安装构建依赖
RUN apt-get update && apt-get install -y gcc
# 复制依赖文件
COPY requirements.txt .
# 安装 Python 依赖
RUN pip install --user --no-cache-dir -r requirements.txt
# 运行时镜像
FROM python:3.11-slim
WORKDIR /app
# 从构建阶段复制依赖
COPY --from=builder /root/.local /root/.local
# 复制应用代码
COPY . .
# 设置 PATH
ENV PATH=/root/.local/bin:$PATH
# 创建非 root 用户
RUN useradd -m appuser && chown -R appuser:appuser /app
USER appuser
# 暴露端口
EXPOSE 5000
# 启动应用
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "--workers", "4", "--threads", "2", "app:app"]
```> **优化效果**:
> - 镜像大小减少 40%
> - 构建时间减少 30%
> - 安全性提高
### 2. Gunicorn 配置优化
```
python
# gunicorn_config.py
import multiprocessing
# 工作进程数
workers = multiprocessing.cpu_count() * 2 + 1
# 线程数
threads = 2
# 工作模式
worker_class = 'gevent'
# 工作进程连接数
worker_connections = 1000
# 超时时间
timeout = 30
keepalive = 2
# 最大请求数
max_requests = 1000
max_requests_jitter = 50
# 日志配置
accesslog = '-'
errorlog = '-'
loglevel = 'info'
# 预加载应用
preload_app = True
# 进程名称
proc_name = 'web-app'
> **优化效果**:
> - 吞吐量提高 50%
> - 响应时间减少 40%
> - 资源利用率提高 30%
### 3. 数据库连接池优化
````python
````python
# config.py
from sqlalchemy import create_engine
from sqlalchemy.pool import QueuePool
engine = create_engine(
DATABASE_URL,
poolclass=QueuePool,
pool_size=20,
max_overflow=40,
pool_timeout=30,
pool_recycle=3600,
pool_pre_ping=True,
echo=False
)
```> **优化效果**:
> - 数据库连接数减少 60%
> - 查询响应时间减少 30%
> - 连接池效率提高 50%
```
### 2. 成本优化
# 示例：优化部署成本
用户请求：
"优化应用部署成本"
Claude Code 生成的优化建议：
## 部署成本优化
### 1. 资源优化
#### Kubernetes 资源配置
````yaml
`yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: web-app
spec:
replicas: 3
template:
spec:
containers:
- name: web-app
resources:
requests:
memory: "128Mi"
cpu: "100m"
limits:
memory: "256Mi"
cpu: "200m"
```> **优化效果**:
> - 资源成本降低 50%
> - 资源利用率提高 40%
### 2. 自动扩缩容
```
yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: web-app-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: web-app
minReplicas: 2
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
> **优化效果**:
> - 成本降低 30%
> - 资源利用率提高 50%
### 3. 节点亲和性
````yaml
````yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: web-app
spec:
template:
spec:
affinity:
nodeAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
preference:
matchExpressions:
- key: node-type
operator: In
values:
- spot
```> **优化效果**:
> - 成本降低 60%
> - 使用 Spot 实例
## 总结
智能部署包括：
1. **自动化部署**: Docker 部署、Kubernetes 部署
2. **部署监控**: 健康检查、日志监控
3. **部署优化**: 性能优化、成本优化
通过这些功能，开发者可以快速、安全地将应用部署到生产环境。
在下一节中，我们将探讨智能维护。
```