【Node.js】摆设与运维

   个人主页：Guiat
归属专栏：node.js
  

  
正文
1. Node.js 摆设概述

Node.js 应用的摆设与运维是将开辟完成的应用程序安全、稳固地运行在生产情况中的关键环节。良好的摆设计谋和运维实践能够确保应用的高可用性、可扩展性和安全性。
1.1 摆设的核心要素

• 情况一致性包管
  
• 应用程序的可靠性和稳固性
  
• 性能优化和资源管理
  
• 安全性和访问控制
  
• 监控和日志管理
  
• 自动化摆设流程
  

1.2 Node.js 摆设架构全景

     2. 传统服务器摆设

2.1 Linux 服务器情况预备

系统更新与基础软件安装

1. # Ubuntu/Debian 系统
2. sudo apt update && sudo apt upgrade -y
4. # 安装必要的软件包
5. sudo apt install -y curl wget git build-essential
7. # CentOS/RHEL 系统
8. sudo yum update -y
9. sudo yum install -y curl wget git gcc-c++ make
11. # 安装 Node.js (使用 NodeSource 仓库)
12. curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
13. sudo apt-get install -y nodejs
15. # 验证安装
16. node --version
17. npm --version

复制代码

创建应用用户

1. # 创建专用的应用用户
2. sudo useradd -m -s /bin/bash nodeapp
3. sudo usermod -aG sudo nodeapp
5. # 切换到应用用户
6. sudo su - nodeapp
8. # 创建应用目录
9. mkdir -p ~/apps/myapp
10. cd ~/apps/myapp

复制代码

2.2 应用摆设脚本

1. #!/bin/bash
2. # deploy.sh - 应用部署脚本
4. set -e
6. APP_NAME="myapp"
7. APP_DIR="/home/nodeapp/apps/$APP_NAME"
8. REPO_URL="https://github.com/username/myapp.git"
9. BRANCH="main"
10. NODE_ENV="production"
12. echo "开始部署 $APP_NAME..."
14. # 创建应用目录
15. mkdir -p $APP_DIR
16. cd $APP_DIR
18. # 克隆或更新代码
19. if [ -d ".git" ]; then
20.     echo "更新代码..."
21.     git fetch origin
22.     git reset --hard origin/$BRANCH
23. else
24.     echo "克隆代码..."
25.     git clone -b $BRANCH $REPO_URL .
26. fi
28. # 安装依赖
29. echo "安装依赖..."
30. npm ci --production
32. # 构建应用
33. echo "构建应用..."
34. npm run build
36. # 设置环境变量
37. echo "设置环境变量..."
38. cp .env.example .env
39. # 根据需要修改 .env 文件
41. # 重启应用
42. echo "重启应用..."
43. pm2 restart $APP_NAME || pm2 start ecosystem.config.js
45. echo "部署完成!"

复制代码

2.3 情况变量管理

1. # .env.production
2. NODE_ENV=production
3. PORT=3000
4. HOST=0.0.0.0
6. # 数据库配置
7. MONGODB_URI=mongodb://localhost:27017/myapp_prod
8. REDIS_URL=redis://localhost:6379
10. # 安全配置
11. JWT_SECRET=your_super_secret_jwt_key_here
12. SESSION_SECRET=your_session_secret_here
14. # 第三方服务
15. SMTP_HOST=smtp.gmail.com
16. SMTP_PORT=587
17. SMTP_USER=your_email@gmail.com
18. SMTP_PASS=your_app_password
20. # 日志配置
21. LOG_LEVEL=info
22. LOG_FILE=/var/log/myapp/app.log
24. # 性能配置
25. MAX_MEMORY=512M
26. CLUSTER_WORKERS=auto

复制代码

2.4 Nginx 反向代理配置

1. # /etc/nginx/sites-available/myapp
2. server {
3.     listen 80;
4.     server_name yourdomain.com www.yourdomain.com;
5.    
6.     # 重定向到 HTTPS
7.     return 301 https://$server_name$request_uri;
8. }
10. server {
11.     listen 443 ssl http2;
12.     server_name yourdomain.com www.yourdomain.com;
13.    
14.     # SSL 证书配置
15.     ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
16.     ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;
17.    
18.     # SSL 安全配置
19.     ssl_protocols TLSv1.2 TLSv1.3;
20.     ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384;
21.     ssl_prefer_server_ciphers off;
22.     ssl_session_cache shared:SSL:10m;
23.     ssl_session_timeout 10m;
24.    
25.     # 安全头
26.     add_header X-Frame-Options DENY;
27.     add_header X-Content-Type-Options nosniff;
28.     add_header X-XSS-Protection "1; mode=block";
29.     add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
30.    
31.     # 静态文件处理
32.     location /static/ {
33.         alias /home/nodeapp/apps/myapp/public/;
34.         expires 1y;
35.         add_header Cache-Control "public, immutable";
36.     }
37.    
38.     # API 代理
39.     location /api/ {
40.         proxy_pass http://127.0.0.1:3000;
41.         proxy_http_version 1.1;
42.         proxy_set_header Upgrade $http_upgrade;
43.         proxy_set_header Connection 'upgrade';
44.         proxy_set_header Host $host;
45.         proxy_set_header X-Real-IP $remote_addr;
46.         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
47.         proxy_set_header X-Forwarded-Proto $scheme;
48.         proxy_cache_bypass $http_upgrade;
49.         
50.         # 超时设置
51.         proxy_connect_timeout 60s;
52.         proxy_send_timeout 60s;
53.         proxy_read_timeout 60s;
54.     }
55.    
56.     # 主应用代理
57.     location / {
58.         proxy_pass http://127.0.0.1:3000;
59.         proxy_http_version 1.1;
60.         proxy_set_header Upgrade $http_upgrade;
61.         proxy_set_header Connection 'upgrade';
62.         proxy_set_header Host $host;
63.         proxy_set_header X-Real-IP $remote_addr;
64.         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
65.         proxy_set_header X-Forwarded-Proto $scheme;
66.         proxy_cache_bypass $http_upgrade;
67.     }
68.    
69.     # 健康检查
70.     location /health {
71.         access_log off;
72.         proxy_pass http://127.0.0.1:3000/health;
73.     }
74. }

复制代码

2.5 SSL 证书配置

1. # 安装 Certbot
2. sudo apt install certbot python3-certbot-nginx
4. # 获取 SSL 证书
5. sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com
7. # 设置自动续期
8. sudo crontab -e
9. # 添加以下行
10. 0 12 * * * /usr/bin/certbot renew --quiet

复制代码

3. PM2 进程管理

3.1 PM2 安装与根本使用

1. # 全局安装 PM2
2. npm install -g pm2
4. # 启动应用
5. pm2 start app.js --name "myapp"
7. # 查看运行状态
8. pm2 status
10. # 查看日志
11. pm2 logs myapp
13. # 重启应用
14. pm2 restart myapp
16. # 停止应用
17. pm2 stop myapp
19. # 删除应用
20. pm2 delete myapp

复制代码

3.2 PM2 配置文件

1. // ecosystem.config.js
2. module.exports = {
3.   apps: [
4.     {
5.       name: 'myapp',
6.       script: './src/index.js',
7.       instances: 'max', // 或者指定数字，如 4
8.       exec_mode: 'cluster',
9.       env: {
10.         NODE_ENV: 'development',
11.         PORT: 3000
12.       },
13.       env_production: {
14.         NODE_ENV: 'production',
15.         PORT: 3000,
16.         MONGODB_URI: 'mongodb://localhost:27017/myapp_prod'
17.       },
18.       // 日志配置
19.       log_file: './logs/combined.log',
20.       out_file: './logs/out.log',
21.       error_file: './logs/error.log',
22.       log_date_format: 'YYYY-MM-DD HH:mm:ss Z',
23.       
24.       // 自动重启配置
25.       watch: false,
26.       ignore_watch: ['node_modules', 'logs'],
27.       max_memory_restart: '1G',
28.       
29.       // 实例配置
30.       min_uptime: '10s',
31.       max_restarts: 10,
32.       
33.       // 健康检查
34.       health_check_grace_period: 3000,
35.       
36.       // 环境变量
37.       env_file: '.env'
38.     }
39.   ],
40.   
41.   deploy: {
42.     production: {
43.       user: 'nodeapp',
44.       host: 'your-server.com',
45.       ref: 'origin/main',
46.       repo: 'https://github.com/username/myapp.git',
47.       path: '/home/nodeapp/apps/myapp',
48.       'post-deploy': 'npm install && npm run build && pm2 reload ecosystem.config.js --env production'
49.     }
50.   }
51. };

复制代码

3.3 PM2 集群模式

1. // cluster.config.js
2. module.exports = {
3.   apps: [
4.     {
5.       name: 'myapp-cluster',
6.       script: './src/index.js',
7.       instances: 4, // 4个工作进程
8.       exec_mode: 'cluster',
9.       
10.       // 负载均衡策略
11.       instance_var: 'INSTANCE_ID',
12.       
13.       // 集群配置
14.       kill_timeout: 5000,
15.       listen_timeout: 3000,
16.       
17.       // 内存和CPU限制
18.       max_memory_restart: '500M',
19.       node_args: '--max-old-space-size=512',
20.       
21.       env_production: {
22.         NODE_ENV: 'production',
23.         PORT: 3000
24.       }
25.     }
26.   ]
27. };

复制代码

3.4 PM2 监控与管理

1. # 实时监控
2. pm2 monit
4. # 查看详细信息
5. pm2 show myapp
7. # 重载所有应用（零停机时间）
8. pm2 reload all
10. # 保存当前进程列表
11. pm2 save
13. # 设置开机自启动
14. pm2 startup
15. pm2 save
17. # 更新 PM2
18. pm2 update

复制代码

3.5 PM2 日志管理

1. # 查看实时日志
2. pm2 logs
4. # 查看特定应用日志
5. pm2 logs myapp
7. # 清空日志
8. pm2 flush
10. # 日志轮转
11. pm2 install pm2-logrotate
13. # 配置日志轮转
14. pm2 set pm2-logrotate:max_size 10M
15. pm2 set pm2-logrotate:retain 30
16. pm2 set pm2-logrotate:compress true

复制代码

4. Docker 容器化摆设

4.1 Dockerfile 最佳实践

1. # 多阶段构建 Dockerfile
2. FROM node:18-alpine AS builder
4. # 设置工作目录
5. WORKDIR /app
7. # 复制 package 文件
8. COPY package*.json ./
10. # 安装依赖
11. RUN npm ci --only=production && npm cache clean --force
13. # 复制源代码
14. COPY . .
16. # 构建应用
17. RUN npm run build
19. # 生产阶段
20. FROM node:18-alpine AS production
22. # 创建非 root 用户
23. RUN addgroup -g 1001 -S nodejs
24. RUN adduser -S nodeapp -u 1001
26. # 设置工作目录
27. WORKDIR /app
29. # 复制构建产物和依赖
30. COPY --from=builder --chown=nodeapp:nodejs /app/dist ./dist
31. COPY --from=builder --chown=nodeapp:nodejs /app/node_modules ./node_modules
32. COPY --from=builder --chown=nodeapp:nodejs /app/package*.json ./
34. # 安装 dumb-init
35. RUN apk add --no-cache dumb-init
37. # 切换到非 root 用户
38. USER nodeapp
40. # 暴露端口
41. EXPOSE 3000
43. # 健康检查
44. HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
45.   CMD node healthcheck.js
47. # 启动应用
48. ENTRYPOINT ["dumb-init", "--"]
49. CMD ["node", "dist/index.js"]

复制代码

4.2 Docker Compose 配置

1. # docker-compose.yml
2. version: '3.8'
4. services:
5.   app:
6.     build:
7.       context: .
8.       dockerfile: Dockerfile
9.       target: production
10.     image: myapp:latest
11.     container_name: myapp
12.     restart: unless-stopped
13.     ports:
14.       - "3000:3000"
15.     environment:
16.       - NODE_ENV=production
17.       - MONGODB_URI=mongodb://mongo:27017/myapp
18.       - REDIS_URL=redis://redis:6379
19.     depends_on:
20.       mongo:
21.         condition: service_healthy
22.       redis:
23.         condition: service_healthy
24.     volumes:
25.       - app_logs:/app/logs
26.       - app_uploads:/app/uploads
27.     networks:
28.       - app_network
29.     healthcheck:
30.       test: ["CMD", "node", "healthcheck.js"]
31.       interval: 30s
32.       timeout: 10s
33.       retries: 3
34.       start_period: 40s
36.   mongo:
37.     image: mongo:6
38.     container_name: myapp_mongo
39.     restart: unless-stopped
40.     ports:
41.       - "27017:27017"
42.     environment:
43.       MONGO_INITDB_ROOT_USERNAME: admin
44.       MONGO_INITDB_ROOT_PASSWORD: password
45.       MONGO_INITDB_DATABASE: myapp
46.     volumes:
47.       - mongo_data:/data/db
48.       - ./mongo-init.js:/docker-entrypoint-initdb.d/mongo-init.js:ro
49.     networks:
50.       - app_network
51.     healthcheck:
52.       test: echo 'db.runCommand("ping").ok' | mongosh localhost:27017/test --quiet
53.       interval: 30s
54.       timeout: 10s
55.       retries: 3
56.       start_period: 40s
58.   redis:
59.     image: redis:7-alpine
60.     container_name: myapp_redis
61.     restart: unless-stopped
62.     ports:
63.       - "6379:6379"
64.     command: redis-server --appendonly yes --requirepass password
65.     volumes:
66.       - redis_data:/data
67.     networks:
68.       - app_network
69.     healthcheck:
70.       test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
71.       interval: 30s
72.       timeout: 10s
73.       retries: 3
74.       start_period: 40s
76.   nginx:
77.     image: nginx:alpine
78.     container_name: myapp_nginx
79.     restart: unless-stopped
80.     ports:
81.       - "80:80"
82.       - "443:443"
83.     volumes:
84.       - ./nginx.conf:/etc/nginx/nginx.conf:ro
85.       - ./ssl:/etc/nginx/ssl:ro
86.       - app_static:/var/www/static:ro
87.     depends_on:
88.       - app
89.     networks:
90.       - app_network
92. volumes:
93.   mongo_data:
94.   redis_data:
95.   app_logs:
96.   app_uploads:
97.   app_static:
99. networks:
100.   app_network:
101.     driver: bridge

复制代码

4.3 康健检查脚本

1. // healthcheck.js
2. const http = require('http');
4. const options = {
5.   hostname: 'localhost',
6.   port: process.env.PORT || 3000,
7.   path: '/health',
8.   method: 'GET',
9.   timeout: 2000
10. };
12. const request = http.request(options, (res) => {
13.   if (res.statusCode === 200) {
14.     process.exit(0);
15.   } else {
16.     process.exit(1);
17.   }
18. });
20. request.on('error', () => {
21.   process.exit(1);
22. });
24. request.on('timeout', () => {
25.   request.destroy();
26.   process.exit(1);
27. });
29. request.end();

复制代码

4.4 Docker 摆设脚本

1. #!/bin/bash
2. # docker-deploy.sh
4. set -e
6. APP_NAME="myapp"
7. IMAGE_NAME="myapp:latest"
8. CONTAINER_NAME="myapp_container"
10. echo "开始 Docker 部署..."
12. # 构建镜像
13. echo "构建 Docker 镜像..."
14. docker build -t $IMAGE_NAME .
16. # 停止并删除旧容器
17. echo "停止旧容器..."
18. docker stop $CONTAINER_NAME 2>/dev/null || true
19. docker rm $CONTAINER_NAME 2>/dev/null || true
21. # 启动新容器
22. echo "启动新容器..."
23. docker run -d \
24.   --name $CONTAINER_NAME \
25.   --restart unless-stopped \
26.   -p 3000:3000 \
27.   -e NODE_ENV=production \
28.   -v $(pwd)/logs:/app/logs \
29.   $IMAGE_NAME
31. # 等待容器启动
32. echo "等待容器启动..."
33. sleep 10
35. # 检查容器状态
36. if docker ps | grep -q $CONTAINER_NAME; then
37.     echo "部署成功! 容器正在运行."
38.     docker logs --tail 20 $CONTAINER_NAME
39. else
40.     echo "部署失败! 容器未能启动."
41.     docker logs $CONTAINER_NAME
42.     exit 1
43. fi

复制代码

4.5 Docker 镜像优化

1. # 优化后的 Dockerfile
2. FROM node:18-alpine AS base
3. RUN apk add --no-cache dumb-init
4. WORKDIR /app
5. COPY package*.json ./
6. RUN npm ci --only=production && npm cache clean --force
8. FROM base AS build
9. RUN npm ci
10. COPY . .
11. RUN npm run build
13. FROM base AS runtime
14. COPY --from=build /app/dist ./dist
15. RUN addgroup -g 1001 -S nodejs && adduser -S nodeapp -u 1001
16. USER nodeapp
17. EXPOSE 3000
18. HEALTHCHECK --interval=30s CMD node healthcheck.js
19. ENTRYPOINT ["dumb-init", "--"]
20. CMD ["node", "dist/index.js"]

复制代码

5. Kubernetes 摆设

5.1 Kubernetes 基础配置

1. # namespace.yaml
2. apiVersion: v1
3. kind: Namespace
4. metadata:
5.   name: myapp
6.   labels:
7.     name: myapp

复制代码

1. # configmap.yaml
2. apiVersion: v1
3. kind: ConfigMap
4. metadata:
5.   name: myapp-config
6.   namespace: myapp
7. data:
8.   NODE_ENV: "production"
9.   PORT: "3000"
10.   LOG_LEVEL: "info"

复制代码

1. # secret.yaml
2. apiVersion: v1
3. kind: Secret
4. metadata:
5.   name: myapp-secrets
6.   namespace: myapp
7. type: Opaque
8. data:
9.   # base64 编码的值
10.   MONGODB_URI: bW9uZ29kYjovL21vbmdvOjI3MDE3L215YXBw
11.   JWT_SECRET: eW91cl9qd3Rfc2VjcmV0X2hlcmU=
12.   REDIS_URL: cmVkaXM6Ly9yZWRpczozNjM3OQ==

复制代码

5.2 Deployment 配置

1. # deployment.yaml
2. apiVersion: apps/v1
3. kind: Deployment
4. metadata:
5.   name: myapp-deployment
6.   namespace: myapp
7.   labels:
8.     app: myapp
9. spec:
10.   replicas: 3
11.   selector:
12.     matchLabels:
13.       app: myapp
14.   template:
15.     metadata:
16.       labels:
17.         app: myapp
18.     spec:
19.       containers:
20.       - name: myapp
21.         image: myapp:latest
22.         ports:
23.         - containerPort: 3000
24.         env:
25.         - name: NODE_ENV
26.           valueFrom:
27.             configMapKeyRef:
28.               name: myapp-config
29.               key: NODE_ENV
30.         - name: PORT
31.           valueFrom:
32.             configMapKeyRef:
33.               name: myapp-config
34.               key: PORT
35.         - name: MONGODB_URI
36.           valueFrom:
37.             secretKeyRef:
38.               name: myapp-secrets
39.               key: MONGODB_URI
40.         - name: JWT_SECRET
41.           valueFrom:
42.             secretKeyRef:
43.               name: myapp-secrets
44.               key: JWT_SECRET
45.         resources:
46.           requests:
47.             memory: "256Mi"
48.             cpu: "250m"
49.           limits:
50.             memory: "512Mi"
51.             cpu: "500m"
52.         livenessProbe:
53.           httpGet:
54.             path: /health
55.             port: 3000
56.           initialDelaySeconds: 30
57.           periodSeconds: 10
58.           timeoutSeconds: 5
59.           failureThreshold: 3
60.         readinessProbe:
61.           httpGet:
62.             path: /ready
63.             port: 3000
64.           initialDelaySeconds: 5
65.           periodSeconds: 5
66.           timeoutSeconds: 3
67.           failureThreshold: 3
68.         volumeMounts:
69.         - name: app-logs
70.           mountPath: /app/logs
71.       volumes:
72.       - name: app-logs
73.         emptyDir: {}
74.       imagePullSecrets:
75.       - name: regcred

复制代码

5.3 Service 配置

1. # service.yaml
2. apiVersion: v1
3. kind: Service
4. metadata:
5.   name: myapp-service
6.   namespace: myapp
7.   labels:
8.     app: myapp
9. spec:
10.   selector:
11.     app: myapp
12.   ports:
13.   - protocol: TCP
14.     port: 80
15.     targetPort: 3000
16.   type: ClusterIP

复制代码

5.4 Ingress 配置

1. # ingress.yaml
2. apiVersion: networking.k8s.io/v1
3. kind: Ingress
4. metadata:
5.   name: myapp-ingress
6.   namespace: myapp
7.   annotations:
8.     kubernetes.io/ingress.class: nginx
9.     cert-manager.io/cluster-issuer: letsencrypt-prod
10.     nginx.ingress.kubernetes.io/rate-limit: "100"
11.     nginx.ingress.kubernetes.io/rate-limit-window: "1m"
12. spec:
13.   tls:
14.   - hosts:
15.     - yourdomain.com
16.     secretName: myapp-tls
17.   rules:
18.   - host: yourdomain.com
19.     http:
20.       paths:
21.       - path: /
22.         pathType: Prefix
23.         backend:
24.           service:
25.             name: myapp-service
26.             port:
27.               number: 80

复制代码

5.5 HorizontalPodAutoscaler

1. # hpa.yaml
2. apiVersion: autoscaling/v2
3. kind: HorizontalPodAutoscaler
4. metadata:
5.   name: myapp-hpa
6.   namespace: myapp
7. spec:
8.   scaleTargetRef:
9.     apiVersion: apps/v1
10.     kind: Deployment
11.     name: myapp-deployment
12.   minReplicas: 2
13.   maxReplicas: 10
14.   metrics:
15.   - type: Resource
16.     resource:
17.       name: cpu
18.       target:
19.         type: Utilization
20.         averageUtilization: 70
21.   - type: Resource
22.     resource:
23.       name: memory
24.       target:
25.         type: Utilization
26.         averageUtilization: 80
27.   behavior:
28.     scaleDown:
29.       stabilizationWindowSeconds: 300
30.       policies:
31.       - type: Percent
32.         value: 10
33.         periodSeconds: 60
34.     scaleUp:
35.       stabilizationWindowSeconds: 0
36.       policies:
37.       - type: Percent
38.         value: 100
39.         periodSeconds: 15
40.       - type: Pods
41.         value: 4
42.         periodSeconds: 15
43.       selectPolicy: Max

复制代码

5.6 Kubernetes 摆设流程

     6. 监控与日志

6.1 应用监控

Prometheus 配置

1. # prometheus.yml
2. global:
3.   scrape_interval: 15s
4.   evaluation_interval: 15s
6. rule_files:
7.   - "rules/*.yml"
9. scrape_configs:
10.   - job_name: 'myapp'
11.     static_configs:
12.       - targets: ['localhost:3000']
13.     metrics_path: '/metrics'
14.     scrape_interval: 5s
16.   - job_name: 'node-exporter'
17.     static_configs:
18.       - targets: ['localhost:9100']
20. alerting:
21.   alertmanagers:
22.     - static_configs:
23.         - targets:
24.           - alertmanager:9093

复制代码

Node.js 应用集成 Prometheus

1. // metrics.js
2. const promClient = require('prom-client');
4. // 创建注册表
5. const register = new promClient.Registry();
7. // 添加默认指标
8. promClient.collectDefaultMetrics({
9.   register,
10.   prefix: 'myapp_'
11. });
13. // 自定义指标
14. const httpRequestDuration = new promClient.Histogram({
15.   name: 'myapp_http_request_duration_seconds',
16.   help: 'HTTP request duration in seconds',
17.   labelNames: ['method', 'route', 'status_code'],
18.   buckets: [0.1, 0.5, 1, 2, 5]
19. });
21. const httpRequestTotal = new promClient.Counter({
22.   name: 'myapp_http_requests_total',
23.   help: 'Total number of HTTP requests',
24.   labelNames: ['method', 'route', 'status_code']
25. });
27. const activeConnections = new promClient.Gauge({
28.   name: 'myapp_active_connections',
29.   help: 'Number of active connections'
30. });
32. // 注册指标
33. register.registerMetric(httpRequestDuration);
34. register.registerMetric(httpRequestTotal);
35. register.registerMetric(activeConnections);
37. // 中间件
38. const metricsMiddleware = (req, res, next) => {
39.   const start = Date.now();
40.   
41.   res.on('finish', () => {
42.     const duration = (Date.now() - start) / 1000;
43.     const route = req.route ? req.route.path : req.path;
44.    
45.     httpRequestDuration
46.       .labels(req.method, route, res.statusCode)
47.       .observe(duration);
48.       
49.     httpRequestTotal
50.       .labels(req.method, route, res.statusCode)
51.       .inc();
52.   });
53.   
54.   next();
55. };
57. module.exports = {
58.   register,
59.   metricsMiddleware,
60.   activeConnections
61. };

复制代码

6.2 日志管理

Winston 日志配置

1. // logger.js
2. const winston = require('winston');
3. const path = require('path');
5. // 自定义日志格式
6. const logFormat = winston.format.combine(
7.   winston.format.timestamp({
8.     format: 'YYYY-MM-DD HH:mm:ss'
9.   }),
10.   winston.format.errors({ stack: true }),
11.   winston.format.json()
12. );
14. // 创建 logger
15. const logger = winston.createLogger({
16.   level: process.env.LOG_LEVEL || 'info',
17.   format: logFormat,
18.   defaultMeta: {
19.     service: 'myapp',
20.     version: process.env.APP_VERSION || '1.0.0'
21.   },
22.   transports: [
23.     // 错误日志
24.     new winston.transports.File({
25.       filename: path.join(__dirname, '../logs/error.log'),
26.       level: 'error',
27.       maxsize: 10485760, // 10MB
28.       maxFiles: 5,
29.       tailable: true
30.     }),
31.    
32.     // 组合日志
33.     new winston.transports.File({
34.       filename: path.join(__dirname, '../logs/combined.log'),
35.       maxsize: 10485760, // 10MB
36.       maxFiles: 5,
37.       tailable: true
38.     }),
39.    
40.     // 控制台输出
41.     new winston.transports.Console({
42.       format: winston.format.combine(
43.         winston.format.colorize(),
44.         winston.format.simple()
45.       )
46.     })
47.   ]
48. });
50. // 请求日志中间件
51. const requestLogger = (req, res, next) => {
52.   const start = Date.now();
53.   
54.   res.on('finish', () => {
55.     const duration = Date.now() - start;
56.    
57.     logger.info('HTTP Request', {
58.       method: req.method,
59.       url: req.url,
60.       statusCode: res.statusCode,
61.       duration: `${duration}ms`,
62.       userAgent: req.get('User-Agent'),
63.       ip: req.ip,
64.       userId: req.user?.id
65.     });
66.   });
67.   
68.   next();
69. };
71. module.exports = { logger, requestLogger };

复制代码

ELK Stack 配置

1. # docker-compose.elk.yml
2. version: '3.8'
4. services:
5.   elasticsearch:
6.     image: docker.elastic.co/elasticsearch/elasticsearch:8.8.0
7.     container_name: elasticsearch
8.     environment:
9.       - discovery.type=single-node
10.       - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
11.       - xpack.security.enabled=false
12.     ports:
13.       - "9200:9200"
14.     volumes:
15.       - elasticsearch_data:/usr/share/elasticsearch/data
17.   logstash:
18.     image: docker.elastic.co/logstash/logstash:8.8.0
19.     container_name: logstash
20.     ports:
21.       - "5044:5044"
22.     volumes:
23.       - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf
24.     depends_on:
25.       - elasticsearch
27.   kibana:
28.     image: docker.elastic.co/kibana/kibana:8.8.0
29.     container_name: kibana
30.     ports:
31.       - "5601:5601"
32.     environment:
33.       - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
34.     depends_on:
35.       - elasticsearch
37. volumes:
38.   elasticsearch_data:

复制代码

1. # logstash.conf
2. input {
3.   beats {
4.     port => 5044
5.   }
6. }
8. filter {
9.   if [fields][service] == "myapp" {
10.     json {
11.       source => "message"
12.     }
13.    
14.     date {
15.       match => [ "timestamp", "yyyy-MM-dd HH:mm:ss" ]
16.     }
17.    
18.     mutate {
19.       remove_field => [ "message", "host", "agent", "ecs", "log", "input" ]
20.     }
21.   }
22. }
24. output {
25.   elasticsearch {
26.     hosts => ["elasticsearch:9200"]
27.     index => "myapp-logs-%{+YYYY.MM.dd}"
28.   }
29. }

复制代码

6.3 APM 监控

New Relic 集成

1. // newrelic.js
2. 'use strict';
4. exports.config = {
5.   app_name: ['MyApp'],
6.   license_key: process.env.NEW_RELIC_LICENSE_KEY,
7.   logging: {
8.     level: 'info'
9.   },
10.   allow_all_headers: true,
11.   attributes: {
12.     exclude: [
13.       'request.headers.cookie',
14.       'request.headers.authorization',
15.       'request.headers.proxyAuthorization',
16.       'request.headers.setCookie*',
17.       'request.headers.x*',
18.       'response.headers.cookie',
19.       'response.headers.authorization',
20.       'response.headers.proxyAuthorization',
21.       'response.headers.setCookie*',
22.       'response.headers.x*'
23.     ]
24.   }
25. };

复制代码

Datadog 集成

1. // app.js
2. const tracer = require('dd-trace').init({
3.   service: 'myapp',
4.   env: process.env.NODE_ENV,
5.   version: process.env.APP_VERSION
6. });
8. const express = require('express');
9. const app = express();
11. // Datadog 中间件
12. app.use((req, res, next) => {
13.   const span = tracer.scope().active();
14.   if (span) {
15.     span.setTag('user.id', req.user?.id);
16.     span.setTag('http.route', req.route?.path);
17.   }
18.   next();
19. });

复制代码

6.4 康健检查端点

1. // health.js
2. const mongoose = require('mongoose');
3. const redis = require('redis');
5. const healthCheck = async (req, res) => {
6.   const health = {
7.     status: 'ok',
8.     timestamp: new Date().toISOString(),
9.     uptime: process.uptime(),
10.     version: process.env.APP_VERSION || '1.0.0',
11.     checks: {}
12.   };
14.   try {
15.     // 数据库连接检查
16.     if (mongoose.connection.readyState === 1) {
17.       health.checks.database = { status: 'ok' };
18.     } else {
19.       health.checks.database = { status: 'error', message: 'Database not connected' };
20.       health.status = 'error';
21.     }
23.     // Redis 连接检查
24.     const redisClient = redis.createClient();
25.     try {
26.       await redisClient.ping();
27.       health.checks.redis = { status: 'ok' };
28.       await redisClient.quit();
29.     } catch (error) {
30.       health.checks.redis = { status: 'error', message: error.message };
31.       health.status = 'error';
32.     }
34.     // 内存使用检查
35.     const memUsage = process.memoryUsage();
36.     health.checks.memory = {
37.       status: 'ok',
38.       usage: {
39.         rss: `${Math.round(memUsage.rss / 1024 / 1024)}MB`,
40.         heapTotal: `${Math.round(memUsage.heapTotal / 1024 / 1024)}MB`,
41.         heapUsed: `${Math.round(memUsage.heapUsed / 1024 / 1024)}MB`
42.       }
43.     };
45.     const statusCode = health.status === 'ok' ? 200 : 503;
46.     res.status(statusCode).json(health);
47.   } catch (error) {
48.     res.status(503).json({
49.       status: 'error',
50.       message: error.message,
51.       timestamp: new Date().toISOString()
52.     });
53.   }
54. };
56. module.exports = { healthCheck };

复制代码

7. 性能优化与扩展

7.1 负载均衡配置

Nginx 负载均衡

1. # nginx.conf
2. upstream myapp_backend {
3.     least_conn;
4.     server 127.0.0.1:3001 weight=3 max_fails=3 fail_timeout=30s;
5.     server 127.0.0.1:3002 weight=3 max_fails=3 fail_timeout=30s;
6.     server 127.0.0.1:3003 weight=2 max_fails=3 fail_timeout=30s;
7.     server 127.0.0.1:3004 backup;
8. }
10. server {
11.     listen 80;
12.     server_name yourdomain.com;
13.    
14.     # 连接限制
15.     limit_conn_zone $binary_remote_addr zone=conn_limit_per_ip:10m;
16.     limit_req_zone $binary_remote_addr zone=req_limit_per_ip:10m rate=5r/s;
17.    
18.     location / {
19.         limit_conn conn_limit_per_ip 10;
20.         limit_req zone=req_limit_per_ip burst=10 nodelay;
21.         
22.         proxy_pass http://myapp_backend;
23.         proxy_http_version 1.1;
24.         proxy_set_header Upgrade $http_upgrade;
25.         proxy_set_header Connection 'upgrade';
26.         proxy_set_header Host $host;
27.         proxy_set_header X-Real-IP $remote_addr;
28.         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
29.         proxy_set_header X-Forwarded-Proto $scheme;
30.         proxy_cache_bypass $http_upgrade;
31.         
32.         # 超时设置
33.         proxy_connect_timeout 5s;
34.         proxy_send_timeout 60s;
35.         proxy_read_timeout 60s;
36.         
37.         # 缓存设置
38.         proxy_cache my_cache;
39.         proxy_cache_valid 200 302 10m;
40.         proxy_cache_valid 404 1m;
41.     }
42. }

复制代码

HAProxy 配置

1. # haproxy.cfg
2. global
3.     daemon
4.     maxconn 4096
5.     log stdout local0
7. defaults
8.     mode http
9.     timeout connect 5000ms
10.     timeout client 50000ms
11.     timeout server 50000ms
12.     option httplog
14. frontend myapp_frontend
15.     bind *:80
16.     default_backend myapp_backend
18. backend myapp_backend
19.     balance roundrobin
20.     option httpchk GET /health
21.     server app1 127.0.0.1:3001 check
22.     server app2 127.0.0.1:3002 check
23.     server app3 127.0.0.1:3003 check
24.     server app4 127.0.0.1:3004 check backup

复制代码

7.2 缓存计谋

Redis 缓存实现

1. // cache.js
2. const redis = require('redis');
3. const client = redis.createClient({
4.   url: process.env.REDIS_URL
5. });
7. client.on('error', (err) => {
8.   console.error('Redis Client Error', err);
9. });
11. client.connect();
13. // 缓存中间件
14. const cacheMiddleware = (duration = 300) => {
15.   return async (req, res, next) => {
16.     if (req.method !== 'GET') {
17.       return next();
18.     }
20.     const key = `cache:${req.originalUrl}`;
21.    
22.     try {
23.       const cached = await client.get(key);
24.       
25.       if (cached) {
26.         return res.json(JSON.parse(cached));
27.       }
29.       // 重写 res.json 方法
30.       const originalJson = res.json;
31.       res.json = function(data) {
32.         // 缓存响应数据
33.         client.setEx(key, duration, JSON.stringify(data));
34.         return originalJson.call(this, data);
35.       };
37.       next();
38.     } catch (error) {
39.       console.error('Cache error:', error);
40.       next();
41.     }
42.   };
43. };
45. // 缓存失效
46. const invalidateCache = async (pattern) => {
47.   try {
48.     const keys = await client.keys(pattern);
49.     if (keys.length > 0) {
50.       await client.del(keys);
51.     }
52.   } catch (error) {
53.     console.error('Cache invalidation error:', error);
54.   }
55. };
57. module.exports = {
58.   client,
59.   cacheMiddleware,
60.   invalidateCache
61. };

复制代码

7.3 数据库优化

MongoDB 优化

1. // database.js
2. const mongoose = require('mongoose');
4. // 连接配置
5. const connectDB = async () => {
6.   try {
7.     const conn = await mongoose.connect(process.env.MONGODB_URI, {
8.       useNewUrlParser: true,
9.       useUnifiedTopology: true,
10.       maxPoolSize: 10, // 连接池大小
11.       serverSelectionTimeoutMS: 5000,
12.       socketTimeoutMS: 45000,
13.       bufferCommands: false,
14.       bufferMaxEntries: 0
15.     });
17.     console.log(`MongoDB Connected: ${conn.connection.host}`);
18.   } catch (error) {
19.     console.error('Database connection error:', error);
20.     process.exit(1);
21.   }
22. };
24. // 索引创建
25. const createIndexes = async () => {
26.   try {
27.     // 用户集合索引
28.     await mongoose.connection.db.collection('users').createIndexes([
29.       { key: { email: 1 }, unique: true },
30.       { key: { username: 1 }, unique: true },
31.       { key: { createdAt: -1 } }
32.     ]);
34.     // 产品集合索引
35.     await mongoose.connection.db.collection('products').createIndexes([
36.       { key: { name: 'text', description: 'text' } },
37.       { key: { category: 1, price: 1 } },
38.       { key: { createdAt: -1 } }
39.     ]);
41.     console.log('Database indexes created');
42.   } catch (error) {
43.     console.error('Index creation error:', error);
44.   }
45. };
47. module.exports = { connectDB, createIndexes };

复制代码

7.4 性能监控

     8. 安全与备份

8.1 安全配置

应用安全中心件

1. // security.js
2. const helmet = require('helmet');
3. const rateLimit = require('express-rate-limit');
4. const mongoSanitize = require('express-mongo-sanitize');
5. const xss = require('xss-clean');
7. // 安全配置
8. const configureSecurity = (app) => {
9.   // 设置安全头
10.   app.use(helmet({
11.     contentSecurityPolicy: {
12.       directives: {
13.         defaultSrc: ["'self'"],
14.         styleSrc: ["'self'", "'unsafe-inline'"],
15.         scriptSrc: ["'self'"],
16.         imgSrc: ["'self'", "data:", "https:"],
17.       },
18.     },
19.     hsts: {
20.       maxAge: 31536000,
21.       includeSubDomains: true,
22.       preload: true
23.     }
24.   }));
26.   // 速率限制
27.   const limiter = rateLimit({
28.     windowMs: 15 * 60 * 1000, // 15分钟
29.     max: 100, // 限制每个IP 100个请求
30.     message: {
31.       error: 'Too many requests, please try again later.'
32.     },
33.     standardHeaders: true,
34.     legacyHeaders: false,
35.   });
37.   app.use('/api/', limiter);
39.   // 严格的认证限制
40.   const authLimiter = rateLimit({
41.     windowMs: 60 * 60 * 1000, // 1小时
42.     max: 5, // 限制每个IP 5次尝试
43.     skipSuccessfulRequests: true,
44.   });
46.   app.use('/api/auth/login', authLimiter);
48.   // 防止 NoSQL 注入
49.   app.use(mongoSanitize());
51.   // 防止 XSS 攻击
52.   app.use(xss());
53. };
55. module.exports = { configureSecurity };

复制代码

SSL/TLS 配置

1. // ssl-server.js
2. const https = require('https');
3. const fs = require('fs');
4. const express = require('express');
6. const app = express();
8. // SSL 证书配置
9. const sslOptions = {
10.   key: fs.readFileSync('/path/to/private-key.pem'),
11.   cert: fs.readFileSync('/path/to/certificate.pem'),
12.   ca: fs.readFileSync('/path/to/ca-certificate.pem'), // 可选
13.   
14.   // 安全配置
15.   secureProtocol: 'TLSv1_2_method',
16.   ciphers: [
17.     'ECDHE-RSA-AES256-GCM-SHA512',
18.     'DHE-RSA-AES256-GCM-SHA512',
19.     'ECDHE-RSA-AES256-GCM-SHA384',
20.     'DHE-RSA-AES256-GCM-SHA384',
21.     'ECDHE-RSA-AES256-SHA384'
22.   ].join(':'),
23.   honorCipherOrder: true
24. };
26. // 创建 HTTPS 服务器
27. const server = https.createServer(sslOptions, app);
29. server.listen(443, () => {
30.   console.log('HTTPS Server running on port 443');
31. });

复制代码

8.2 数据备份计谋

MongoDB 备份脚本

1. #!/bin/bash
2. # mongodb-backup.sh
4. set -e
6. # 配置
7. DB_NAME="myapp"
8. BACKUP_DIR="/backup/mongodb"
9. DATE=$(date +%Y%m%d_%H%M%S)
10. BACKUP_NAME="mongodb_backup_${DATE}"
11. RETENTION_DAYS=7
13. # 创建备份目录
14. mkdir -p $BACKUP_DIR
16. # 执行备份
17. echo "开始备份 MongoDB 数据库: $DB_NAME"
18. mongodump --db $DB_NAME --out $BACKUP_DIR/$BACKUP_NAME
20. # 压缩备份
21. echo "压缩备份文件..."
22. tar -czf $BACKUP_DIR/${BACKUP_NAME}.tar.gz -C $BACKUP_DIR $BACKUP_NAME
23. rm -rf $BACKUP_DIR/$BACKUP_NAME
25. # 清理旧备份
26. echo "清理 $RETENTION_DAYS 天前的备份..."
27. find $BACKUP_DIR -name "mongodb_backup_*.tar.gz" -mtime +$RETENTION_DAYS -delete
29. # 上传到云存储 (可选)
30. if [ ! -z "$AWS_S3_BUCKET" ]; then
31.     echo "上传备份到 S3..."
32.     aws s3 cp $BACKUP_DIR/${BACKUP_NAME}.tar.gz s3://$AWS_S3_BUCKET/mongodb-backups/
33. fi
35. echo "备份完成: ${BACKUP_NAME}.tar.gz"

复制代码

自动化备份配置

1. # 添加到 crontab
2. # 每天凌晨 2 点执行备份
3. 0 2 * * * /path/to/mongodb-backup.sh >> /var/log/mongodb-backup.log 2>&1
5. # 每周日凌晨 3 点执行完整备份
6. 0 3 * * 0 /path/to/full-backup.sh >> /var/log/full-backup.log 2>&1

复制代码

8.3 灾难规复

规复脚本

1. #!/bin/bash
2. # mongodb-restore.sh
4. set -e
6. BACKUP_FILE=$1
7. DB_NAME="myapp"
8. TEMP_DIR="/tmp/mongodb_restore"
10. if [ -z "$BACKUP_FILE" ]; then
11.     echo "用法: $0 <backup_file.tar.gz>"
12.     exit 1
13. fi
15. echo "开始恢复 MongoDB 数据库..."
17. # 创建临时目录
18. mkdir -p $TEMP_DIR
20. # 解压备份文件
21. echo "解压备份文件..."
22. tar -xzf $BACKUP_FILE -C $TEMP_DIR
24. # 获取备份目录名
25. BACKUP_DIR=$(ls $TEMP_DIR)
27. # 停止应用服务
28. echo "停止应用服务..."
29. pm2 stop myapp
31. # 恢复数据库
32. echo "恢复数据库..."
33. mongorestore --db $DB_NAME --drop $TEMP_DIR/$BACKUP_DIR/$DB_NAME
35. # 启动应用服务
36. echo "启动应用服务..."
37. pm2 start myapp
39. # 清理临时文件
40. rm -rf $TEMP_DIR
42. echo "数据库恢复完成!"

复制代码

9. 故障排查与调试

9.1 常见题目诊断

内存走漏检测

1. // memory-monitor.js
2. const v8 = require('v8');
3. const fs = require('fs');
5. // 内存使用监控
6. const monitorMemory = () => {
7.   const usage = process.memoryUsage();
8.   const heapStats = v8.getHeapStatistics();
9.   
10.   console.log('Memory Usage:', {
11.     rss: `${Math.round(usage.rss / 1024 / 1024)}MB`,
12.     heapTotal: `${Math.round(usage.heapTotal / 1024 / 1024)}MB`,
13.     heapUsed: `${Math.round(usage.heapUsed / 1024 / 1024)}MB`,
14.     external: `${Math.round(usage.external / 1024 / 1024)}MB`,
15.     heapLimit: `${Math.round(heapStats.heap_size_limit / 1024 / 1024)}MB`
16.   });
17.   
18.   // 如果内存使用超过阈值，生成堆快照
19.   if (usage.heapUsed > 500 * 1024 * 1024) { // 500MB
20.     const snapshot = v8.writeHeapSnapshot();
21.     console.log('Heap snapshot written to:', snapshot);
22.   }
23. };
25. // 每分钟检查一次内存使用
26. setInterval(monitorMemory, 60000);
28. module.exports = { monitorMemory };

复制代码

性能分析

1. // profiler.js
2. const inspector = require('inspector');
3. const fs = require('fs');
4. const path = require('path');
6. class Profiler {
7.   constructor() {
8.     this.session = null;
9.   }
11.   start() {
12.     this.session = new inspector.Session();
13.     this.session.connect();
14.    
15.     // 启用 CPU 分析器
16.     this.session.post('Profiler.enable');
17.     this.session.post('Profiler.start');
18.    
19.     console.log('CPU profiler started');
20.   }
22.   async stop() {
23.     if (!this.session) return;
25.     return new Promise((resolve, reject) => {
26.       this.session.post('Profiler.stop', (err, { profile }) => {
27.         if (err) {
28.           reject(err);
29.           return;
30.         }
32.         const filename = `cpu-profile-${Date.now()}.cpuprofile`;
33.         const filepath = path.join(__dirname, '../profiles', filename);
34.         
35.         fs.writeFileSync(filepath, JSON.stringify(profile));
36.         console.log('CPU profile saved to:', filepath);
37.         
38.         this.session.disconnect();
39.         resolve(filepath);
40.       });
41.     });
42.   }
43. }
45. module.exports = Profiler;

复制代码

9.2 日志分析

错误追踪

1. // error-tracker.js
2. const Sentry = require('@sentry/node');
4. // 初始化 Sentry
5. Sentry.init({
6.   dsn: process.env.SENTRY_DSN,
7.   environment: process.env.NODE_ENV,
8.   tracesSampleRate: 1.0,
9. });
11. // 错误处理中间件
12. const errorHandler = (err, req, res, next) => {
13.   // 记录错误到 Sentry
14.   Sentry.captureException(err, {
15.     user: {
16.       id: req.user?.id,
17.       email: req.user?.email
18.     },
19.     request: {
20.       method: req.method,
21.       url: req.url,
22.       headers: req.headers
23.     }
24.   });
26.   // 记录到本地日志
27.   console.error('Error:', {
28.     message: err.message,
29.     stack: err.stack,
30.     url: req.url,
31.     method: req.method,
32.     userId: req.user?.id,
33.     timestamp: new Date().toISOString()
34.   });
36.   // 返回错误响应
37.   const statusCode = err.statusCode || 500;
38.   res.status(statusCode).json({
39.     error: {
40.       message: process.env.NODE_ENV === 'production'
41.         ? 'Internal Server Error'
42.         : err.message,
43.       status: statusCode
44.     }
45.   });
46. };
48. module.exports = { errorHandler };

复制代码

9.3 调试工具

长途调试配置

1. # 启动应用时启用调试模式
2. node --inspect=0.0.0.0:9229 src/index.js
4. # 或者使用 PM2
5. pm2 start src/index.js --node-args="--inspect=0.0.0.0:9229"

复制代码

调试脚本

1. // debug-utils.js
2. const util = require('util');
3. const fs = require('fs');
5. // 深度日志记录
6. const deepLog = (obj, label = 'Debug') => {
7.   console.log(`\n=== ${label} ===`);
8.   console.log(util.inspect(obj, {
9.     depth: null,
10.     colors: true,
11.     showHidden: false
12.   }));
13.   console.log('='.repeat(label.length + 8));
14. };
16. // 性能计时器
17. class Timer {
18.   constructor(label) {
19.     this.label = label;
20.     this.start = process.hrtime.bigint();
21.   }
23.   end() {
24.     const end = process.hrtime.bigint();
25.     const duration = Number(end - this.start) / 1000000; // 转换为毫秒
26.     console.log(`${this.label}: ${duration.toFixed(2)}ms`);
27.     return duration;
28.   }
29. }
31. // 内存快照
32. const takeMemorySnapshot = () => {
33.   const usage = process.memoryUsage();
34.   const snapshot = {
35.     timestamp: new Date().toISOString(),
36.     pid: process.pid,
37.     memory: {
38.       rss: usage.rss,
39.       heapTotal: usage.heapTotal,
40.       heapUsed: usage.heapUsed,
41.       external: usage.external
42.     }
43.   };
44.   
45.   const filename = `memory-snapshot-${Date.now()}.json`;
46.   fs.writeFileSync(filename, JSON.stringify(snapshot, null, 2));
47.   console.log('Memory snapshot saved to:', filename);
48.   
49.   return snapshot;
50. };
52. module.exports = {
53.   deepLog,
54.   Timer,
55.   takeMemorySnapshot
56. };

复制代码

10. 最佳实践与总结

10.1 摆设最佳实践

摆设检查清单

     情况管理计谋

1. // config/environments.js
2. const environments = {
3.   development: {
4.     port: 3000,
5.     database: {
6.       uri: 'mongodb://localhost:27017/myapp_dev',
7.       options: {
8.         useNewUrlParser: true,
9.         useUnifiedTopology: true
10.       }
11.     },
12.     redis: {
13.       url: 'redis://localhost:6379'
14.     },
15.     logging: {
16.       level: 'debug',
17.       console: true
18.     },
19.     security: {
20.       cors: {
21.         origin: '*'
22.       }
23.     }
24.   },
25.   
26.   staging: {
27.     port: process.env.PORT || 3000,
28.     database: {
29.       uri: process.env.MONGODB_URI,
30.       options: {
31.         useNewUrlParser: true,
32.         useUnifiedTopology: true,
33.         maxPoolSize: 5
34.       }
35.     },
36.     redis: {
37.       url: process.env.REDIS_URL
38.     },
39.     logging: {
40.       level: 'info',
41.       console: false,
42.       file: true
43.     },
44.     security: {
45.       cors: {
46.         origin: process.env.ALLOWED_ORIGINS?.split(',') || []
47.       }
48.     }
49.   },
50.   
51.   production: {
52.     port: process.env.PORT || 3000,
53.     database: {
54.       uri: process.env.MONGODB_URI,
55.       options: {
56.         useNewUrlParser: true,
57.         useUnifiedTopology: true,
58.         maxPoolSize: 10,
59.         serverSelectionTimeoutMS: 5000,
60.         socketTimeoutMS: 45000
61.       }
62.     },
63.     redis: {
64.       url: process.env.REDIS_URL,
65.       options: {
66.         retryDelayOnFailover: 100,
67.         maxRetriesPerRequest: 3
68.       }
69.     },
70.     logging: {
71.       level: 'warn',
72.       console: false,
73.       file: true,
74.       sentry: true
75.     },
76.     security: {
77.       cors: {
78.         origin: process.env.ALLOWED_ORIGINS?.split(',') || []
79.       },
80.       rateLimit: {
81.         windowMs: 15 * 60 * 1000,
82.         max: 100
83.       }
84.     }
85.   }
86. };
88. module.exports = environments[process.env.NODE_ENV || 'development'];

复制代码

10.2 运维自动化

自动化摆设脚本

1. #!/bin/bash
2. # auto-deploy.sh
4. set -e
6. # 配置
7. APP_NAME="myapp"
8. DEPLOY_USER="deploy"
9. DEPLOY_HOST="your-server.com"
10. DEPLOY_PATH="/opt/apps/$APP_NAME"
11. BACKUP_PATH="/opt/backups/$APP_NAME"
12. HEALTH_CHECK_URL="http://localhost:3000/health"
14. # 颜色输出
15. RED='\033[0;31m'
16. GREEN='\033[0;32m'
17. YELLOW='\033[1;33m'
18. NC='\033[0m' # No Color
20. log() {
21.     echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')] $1${NC}"
22. }
24. warn() {
25.     echo -e "${YELLOW}[$(date +'%Y-%m-%d %H:%M:%S')] WARNING: $1${NC}"
26. }
28. error() {
29.     echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] ERROR: $1${NC}"
30.     exit 1
31. }
33. # 预检查
34. pre_deploy_check() {
35.     log "执行部署前检查..."
36.    
37.     # 检查 Git 状态
38.     if [[ -n $(git status --porcelain) ]]; then
39.         error "工作目录不干净，请提交或暂存更改"
40.     fi
41.    
42.     # 检查测试
43.     log "运行测试..."
44.     npm test || error "测试失败"
45.    
46.     # 检查构建
47.     log "检查构建..."
48.     npm run build || error "构建失败"
49.    
50.     log "预检查完成"
51. }
53. # 备份当前版本
54. backup_current() {
55.     log "备份当前版本..."
56.    
57.     ssh $DEPLOY_USER@$DEPLOY_HOST "
58.         if [ -d $DEPLOY_PATH ]; then
59.             sudo mkdir -p $BACKUP_PATH
60.             sudo cp -r $DEPLOY_PATH $BACKUP_PATH/backup-$(date +%Y%m%d_%H%M%S)
61.             # 保留最近5个备份
62.             sudo ls -t $BACKUP_PATH | tail -n +6 | xargs -r sudo rm -rf
63.         fi
64.     "
65.    
66.     log "备份完成"
67. }
69. # 部署新版本
70. deploy() {
71.     log "开始部署..."
72.    
73.     # 上传代码
74.     rsync -avz --delete \
75.         --exclude 'node_modules' \
76.         --exclude '.git' \
77.         --exclude 'logs' \
78.         ./ $DEPLOY_USER@$DEPLOY_HOST:$DEPLOY_PATH/
79.    
80.     # 远程部署命令
81.     ssh $DEPLOY_USER@$DEPLOY_HOST "
82.         cd $DEPLOY_PATH
83.         npm ci --production
84.         npm run build
85.         sudo systemctl reload nginx
86.         pm2 reload ecosystem.config.js --env production
87.     "
88.    
89.     log "部署完成"
90. }
92. # 健康检查
93. health_check() {
94.     log "执行健康检查..."
95.    
96.     local max_attempts=30
97.     local attempt=1
98.    
99.     while [ $attempt -le $max_attempts ]; do
100.         if ssh $DEPLOY_USER@$DEPLOY_HOST "curl -f $HEALTH_CHECK_URL > /dev/null 2>&1"; then
101.             log "健康检查通过"
102.             return 0
103.         fi
104.         
105.         warn "健康检查失败 (尝试 $attempt/$max_attempts)"
106.         sleep 10
107.         ((attempt++))
108.     done
109.    
110.     error "健康检查失败，部署可能有问题"
111. }
113. # 回滚
114. rollback() {
115.     warn "开始回滚..."
116.    
117.     ssh $DEPLOY_USER@$DEPLOY_HOST "
118.         latest_backup=\$(ls -t $BACKUP_PATH | head -n 1)
119.         if [ -n "\$latest_backup" ]; then
120.             sudo rm -rf $DEPLOY_PATH
121.             sudo cp -r $BACKUP_PATH/\$latest_backup $DEPLOY_PATH
122.             pm2 reload ecosystem.config.js --env production
123.         else
124.             echo 'No backup found for rollback'
125.             exit 1
126.         fi
127.     "
128.    
129.     warn "回滚完成"
130. }
132. # 主流程
133. main() {
134.     log "开始自动化部署流程..."
135.    
136.     pre_deploy_check
137.     backup_current
138.     deploy
139.    
140.     if health_check; then
141.         log "部署成功完成!"
142.     else
143.         error "部署失败，开始回滚..."
144.         rollback
145.         health_check || error "回滚后健康检查仍然失败"
146.         warn "已回滚到之前版本"
147.     fi
148. }
150. # 捕获错误并回滚
151. trap 'error "部署过程中发生错误"' ERR
153. # 执行主流程
154. main "$@"

复制代码

10.3 监控告警配置

Prometheus 告警规则

1. # alerts.yml
2. groups:
3.   - name: myapp.rules
4.     rules:
5.       - alert: HighErrorRate
6.         expr: rate(myapp_http_requests_total{status_code=~"5.."}[5m]) > 0.1
7.         for: 5m
8.         labels:
9.           severity: critical
10.         annotations:
11.           summary: "High error rate detected"
12.           description: "Error rate is {{ $value }} errors per second"
14.       - alert: HighResponseTime
15.         expr: histogram_quantile(0.95, rate(myapp_http_request_duration_seconds_bucket[5m])) > 1
16.         for: 5m
17.         labels:
18.           severity: warning
19.         annotations:
20.           summary: "High response time detected"
21.           description: "95th percentile response time is {{ $value }} seconds"
23.       - alert: HighMemoryUsage
24.         expr: (myapp_process_resident_memory_bytes / 1024 / 1024) > 512
25.         for: 10m
26.         labels:
27.           severity: warning
28.         annotations:
29.           summary: "High memory usage"
30.           description: "Memory usage is {{ $value }}MB"
32.       - alert: ServiceDown
33.         expr: up{job="myapp"} == 0
34.         for: 1m
35.         labels:
36.           severity: critical
37.         annotations:
38.           summary: "Service is down"
39.           description: "MyApp service is not responding"

复制代码

告警通知配置

1. # alertmanager.yml
2. global:
3.   smtp_smarthost: 'smtp.gmail.com:587'
4.   smtp_from: 'alerts@yourdomain.com'
6. route:
7.   group_by: ['alertname']
8.   group_wait: 10s
9.   group_interval: 10s
10.   repeat_interval: 1h
11.   receiver: 'web.hook'
13. receivers:
14.   - name: 'web.hook'
15.     email_configs:
16.       - to: 'admin@yourdomain.com'
17.         subject: 'Alert: {{ .GroupLabels.alertname }}'
18.         body: |
19.           {{ range .Alerts }}
20.           Alert: {{ .Annotations.summary }}
21.           Description: {{ .Annotations.description }}
22.           {{ end }}
23.    
24.     slack_configs:
25.       - api_url: 'YOUR_SLACK_WEBHOOK_URL'
26.         channel: '#alerts'
27.         title: 'Alert: {{ .GroupLabels.alertname }}'
28.         text: |
29.           {{ range .Alerts }}
30.           {{ .Annotations.summary }}
31.           {{ .Annotations.description }}
32.           {{ end }}

复制代码

10.4 总结

Node.js 应用的摆设与运维是一个复杂的系统工程，需要思量多个方面：
关键要点

• 情况一致性：使用容器化技能确保开辟、测试、生产情况的一致性
  
• 自动化流程：建立完备的 CI/CD 流水线，淘汰人工操作错误
  
• 监控体系：建立全面的监控和告警系统，及时发现息争决题目
  
• 安全防护：实施多层安全防护措施，保护应用和数据安全
  
• 性能优化：通过负载均衡、缓存、数据库优化等手段提拔性能
  
• 故障规复：建立完善的备份和规复机制，确保业务连续性
  

技能选型建议

• 小型应用：PM2 + Nginx + 传统服务器摆设
  
• 中型应用：Docker + Docker Compose + 云服务器
  
• 大型应用：Kubernetes + 微服务架构 + 云原生技能栈
  

运维成熟度模型

     通过逐步实施这些最佳实践，可以构建一个稳固、可靠、高性能的 Node.js 应用运行情况，为业务发展提供坚固的技能保障。
结语
感谢您的阅读！等待您的一键三连！欢迎指正！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。