- \n
- \n
HTTP\/1.1 RFC 7231\u5b9a\u4e49：\u670d\u52a1\u5668\u9047\u5230\u4e86\u610f\u5916\u60c5\u51b5，\u963b\u6b62\u5176\u5b8c\u6210\u8bf7\u6c42<\/p>\n<\/li>\n
- \n
\u72b6\u6001\u7801\u8bed\u4e49：\u901a\u7528\u9519\u8bef\u54cd\u5e94，\u5f53\u6ca1\u6709\u66f4\u5177\u4f53\u6d88\u606f\u5408\u9002\u65f6\u4f7f\u7528<\/p>\n<\/li>\n
- \n
\u5173\u952e\u7279\u5f81：<\/p>\n
- \n
- \n
\u670d\u52a1\u5668\u7aef\u6545\u969c\u7684"\u515c\u5e95"\u72b6\u6001\u7801<\/p>\n<\/li>\n
- \n
\u901a\u5e38\u4f34\u968f\u670d\u52a1\u5668\u7aef\u5f02\u5e38\u5806\u6808\u6216\u65e5\u5fd7<\/p>\n<\/li>\n
- \n
\u5ba2\u6237\u7aef\u65e0\u6cd5\u901a\u8fc7\u4fee\u6539\u8bf7\u6c42\u89e3\u51b3\u6b64\u95ee\u9898<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
24.1.2 \u4e0e\u76f8\u5173\u72b6\u6001\u7801\u7684\u533a\u5206
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/07\/20260726181654-6a664f16b62ae.png\")
<\/h5>\n<\/p>\n24.2 \u5178\u578b\u89e6\u53d1\u573a\u666f\u4e0e\u6848\u4f8b\u5206\u6790<\/h4>\n
24.2.1 \u4ee3\u7801\u7ea7\u5f02\u5e38（\u6700\u5e38\u89c1\u573a\u666f）<\/h5>\n
\u6848\u4f8b\u4e00：\u672a\u6355\u83b7\u7684\u8fd0\u884c\u65f6\u5f02\u5e38<\/p>\n
python<\/p>\n
# \u9519\u8bef\u793a\u4f8b：\u7f3a\u4e4f\u5f02\u5e38\u5904\u7406\u7684\u5371\u9669\u4ee3\u7801
\n@app.route('\/process-data')
\ndef process_data():
\n # \u672a\u9a8c\u8bc1\u8f93\u5165\u53ef\u80fd\u5bfc\u81f4\u5404\u79cd\u5f02\u5e38
\n data = request.json['data'] # KeyError\u5982\u679c'data'\u4e0d\u5b58\u5728
\n result = complex_processing(data) # \u53ef\u80fd\u629b\u51fa\u5404\u79cd\u5f02\u5e38
\n return jsonify(result)<\/p>\n# \u6b63\u786e\u793a\u4f8b：\u9632\u5fa1\u6027\u7f16\u7a0b
\n@app.route('\/process-data')
\ndef process_data():
\n try:
\n data = request.json.get('data')
\n if not data:
\n return jsonify({'error': 'Missing data field'}), 400<\/p>\n# \u8f93\u5165\u9a8c\u8bc1
\n if not validate_input(data):
\n return jsonify({'error': 'Invalid input format'}), 422<\/p>\nresult = safe_processing(data)
\n return jsonify(result)<\/p>\nexcept SpecificException as e:
\n logger.error(f"Processing failed: {str(e)}")
\n return jsonify({'error': 'Processing failed'}), 500<\/p>\nexcept Exception as e:
\n # \u5168\u5c40\u5f02\u5e38\u5904\u7406
\n logger.critical(f"Unexpected error: {str(e)}", exc_info=True)
\n # \u53ef\u4ee5\u8003\u8651\u8fd4\u56de\u66f4\u53cb\u597d\u7684\u9519\u8bef\u4fe1\u606f
\n return jsonify({'error': 'Internal server error'}), 500<\/p>\n\u6848\u4f8b\u4e8c：\u8d44\u6e90\u6cc4\u6f0f\u5bfc\u81f4\u7684\u7cfb\u7edf\u5d29\u6e83<\/p>\n
java<\/p>\n
\/\/ \u6570\u636e\u5e93\u8fde\u63a5\u6cc4\u6f0f\u793a\u4f8b
\npublic class UserService {
\n public User getUser(String userId) {
\n Connection conn = null;
\n try {
\n conn = dataSource.getConnection();
\n \/\/ \u6267\u884c\u67e5\u8be2
\n return executeQuery(conn, userId);
\n } catch (SQLException e) {
\n \/\/ \u9519\u8bef：\u8fde\u63a5\u672a\u5728finally\u5757\u4e2d\u5173\u95ed
\n throw new RuntimeException("Query failed", e);
\n }
\n \/\/ \u7f3a\u5c11finally\u5757\u5173\u95ed\u8fde\u63a5
\n }
\n}<\/p>\n\/\/ \u6539\u8fdb\u65b9\u6848：\u4f7f\u7528try-with-resources
\npublic User getUser(String userId) {
\n try (Connection conn = dataSource.getConnection();
\n PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users WHERE id=?")) {<\/p>\nstmt.setString(1, userId);
\n try (ResultSet rs = stmt.executeQuery()) {
\n if (rs.next()) {
\n return mapToUser(rs);
\n }
\n }
\n } catch (SQLException e) {
\n logger.error("Database error", e);
\n throw new ServiceException("Failed to retrieve user", e);
\n }
\n return null;
\n}<\/p>\n24.2.2 \u914d\u7f6e\u9519\u8bef\u573a\u666f<\/h5>\n
Nginx + PHP-FPM\u914d\u7f6e\u95ee\u9898\u5206\u6790：<\/p>\n
nginx<\/p>\n
# \u9519\u8bef\u914d\u7f6e\u793a\u4f8b
\nserver {
\n listen 80;
\n server_name example.com;<\/p>\nlocation ~ \\\\.php$ {
\n fastcgi_pass unix:\/var\/run\/php\/php7.4-fpm.sock;
\n # \u9519\u8bef\u7684socket\u8def\u5f84\u6216\u6743\u9650\u95ee\u9898
\n fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
\n include fastcgi_params;
\n }
\n}<\/p>\n# \u5e38\u89c1\u914d\u7f6e\u95ee\u9898\u68c0\u67e5\u6e05\u5355：
\n# 1. Socket\u6587\u4ef6\u6743\u9650：ls -l \/var\/run\/php\/php7.4-fpm.sock
\n# 2. PHP-FPM\u8fdb\u7a0b\u7528\u6237\u4e0eNginx\u7528\u6237\u662f\u5426\u5339\u914d
\n# 3. SCRIPT_FILENAME\u53c2\u6570\u662f\u5426\u6b63\u786e\u8bbe\u7f6e
\n# 4. \u6587\u4ef6\u7cfb\u7edf\u6743\u9650\u95ee\u9898<\/p>\n24.2.3 \u7b2c\u4e09\u65b9\u4f9d\u8d56\u6545\u969c<\/h5>\n
python<\/p>\n
# \u5916\u90e8API\u8c03\u7528\u5bfc\u81f4\u7684\u7ea7\u8054\u6545\u969c
\nclass PaymentService:
\n def __init__(self):
\n self.gateway_url = os.getenv('PAYMENT_GATEWAY_URL')
\n self.timeout = int(os.getenv('PAYMENT_TIMEOUT', 5))<\/p>\ndef process_payment(self, order):
\n try:
\n response = requests.post(
\n f"{self.gateway_url}\/charge",
\n json=order.to_dict(),
\n timeout=self.timeout
\n )
\n response.raise_for_status()
\n return response.json()<\/p>\nexcept requests.exceptions.Timeout:
\n # \u8d85\u65f6\u5904\u7406\u7b56\u7565
\n logger.error(f"Payment gateway timeout after {self.timeout}s")
\n raise PaymentGatewayTimeout("Payment service unavailable")<\/p>\nexcept requests.exceptions.ConnectionError:
\n # \u8fde\u63a5\u5931\u8d25\u5904\u7406
\n logger.error("Cannot connect to payment gateway")
\n raise PaymentGatewayError("Payment service connection failed")<\/p>\nexcept requests.exceptions.RequestException as e:
\n # \u5176\u4ed6\u8bf7\u6c42\u5f02\u5e38
\n logger.error(f"Payment gateway error: {str(e)}")
\n raise PaymentGatewayError("Payment processing failed")<\/p>\n24.3 \u7cfb\u7edf\u5316\u8bca\u65ad\u65b9\u6cd5\u8bba<\/h4>\n
24.3.1 \u5206\u5c42\u8bca\u65ad\u6846\u67b6<\/h5>\n
\u8bca\u65ad\u91d1\u5b57\u5854\u6a21\u578b：<\/p>\n
text<\/p>\n
\u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
\n\u2502 \u4e1a\u52a1\u5c42\u9762\u76d1\u63a7 \u2502
\n\u2502 \u2022 \u7528\u6237\u6295\u8bc9 \u2502
\n\u2502 \u2022 \u4e1a\u52a1\u6307\u6807\u5f02\u5e38 \u2502
\n\u2502 \u2022 \u4ea4\u6613\u5931\u8d25\u7387\u4e0a\u5347 \u2502
\n\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
\n \u25bc
\n\u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
\n\u2502 \u5e94\u7528\u5c42\u9762\u8bca\u65ad \u2502
\n\u2502 \u2022 \u9519\u8bef\u65e5\u5fd7\u5206\u6790 \u2502
\n\u2502 \u2022 \u5e94\u7528\u6027\u80fd\u76d1\u63a7(APM) \u2502
\n\u2502 \u2022 \u5806\u6808\u8ddf\u8e2a\u89e3\u6790 \u2502
\n\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
\n \u25bc
\n\u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
\n\u2502 \u7cfb\u7edf\u5c42\u9762\u68c0\u67e5 \u2502
\n\u2502 \u2022 \u7cfb\u7edf\u65e5\u5fd7(\/var\/log\/) \u2502
\n\u2502 \u2022 \u8d44\u6e90\u4f7f\u7528\u7387(CPU\/\u5185\u5b58\/\u78c1\u76d8) \u2502
\n\u2502 \u2022 \u8fdb\u7a0b\u72b6\u6001\u76d1\u63a7 \u2502
\n\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
\n \u25bc
\n\u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
\n\u2502 \u57fa\u7840\u8bbe\u65bd\u5c42 \u2502
\n\u2502 \u2022 \u7f51\u7edc\u8fde\u901a\u6027 \u2502
\n\u2502 \u2022 \u8d1f\u8f7d\u5747\u8861\u72b6\u6001 \u2502
\n\u2502 \u2022 \u6570\u636e\u5e93\u8fde\u63a5\u6c60 \u2502
\n\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518<\/p>\n24.3.2 \u8bca\u65ad\u547d\u4ee4\u4e0e\u5de5\u5177\u96c6<\/h5>\n
\u5b9e\u65f6\u8bca\u65ad\u5de5\u5177\u7bb1：<\/p>\n
bash<\/p>\n
#!\/bin\/bash
\n# 500\u9519\u8bef\u8bca\u65ad\u811a\u672c\u793a\u4f8b<\/p>\n# 1. \u68c0\u67e5Web\u670d\u52a1\u5668\u9519\u8bef\u65e5\u5fd7
\ntail -100 \/var\/log\/nginx\/error.log | grep -A5 -B5 "500"
\ntail -100 \/var\/log\/apache2\/error.log | grep -i "internal"<\/p>\n# 2. \u68c0\u67e5\u5e94\u7528\u65e5\u5fd7
\njournalctl -u your-application.service –since "10 minutes ago" | tail -50<\/p>\n# 3. \u7cfb\u7edf\u8d44\u6e90\u68c0\u67e5
\ntop -b -n 1 | head -20
\nfree -h
\ndf -h<\/p>\n# 4. \u7f51\u7edc\u8fde\u63a5\u72b6\u6001
\nnetstat -tulpn | grep -E "(80|443)"
\nss -tulpn | grep LISTEN<\/p>\n# 5. \u8fdb\u7a0b\u68c0\u67e5
\nps aux | grep -E "(nginx|apache|php|python|java)" | head -20<\/p>\n# 6. \u6570\u636e\u5e93\u8fde\u63a5\u68c0\u67e5
\n# MySQL
\nmysqladmin -u root -p status
\n# PostgreSQL
\npg_isready -h localhost<\/p>\n# 7. \u78c1\u76d8I\/O\u68c0\u67e5
\niostat -x 1 5<\/p>\n# 8. \u5185\u5b58\u6cc4\u6f0f\u68c0\u67e5
\ncat \/proc\/meminfo | grep -E "(MemFree|Cached|Swap)"<\/p>\n# 9. \u81ea\u52a8\u751f\u6210\u8bca\u65ad\u62a5\u544a
\necho "=== 500\u9519\u8bef\u8bca\u65ad\u62a5\u544a ===" > \/tmp\/diagnosis_$(date +%s).txt
\necho "\u65f6\u95f4: $(date)" >> \/tmp\/diagnosis.txt
\ndmesg | tail -20 >> \/tmp\/diagnosis.txt<\/p>\n24.4 \u9ad8\u7ea7\u89e3\u51b3\u65b9\u6848\u4e0e\u6700\u4f73\u5b9e\u8df5<\/h4>\n
24.4.1 \u4f18\u96c5\u964d\u7ea7\u4e0e\u6545\u969c\u9694\u79bb<\/h5>\n
java<\/p>\n
\/\/ \u4f7f\u7528\u65ad\u8def\u5668\u6a21\u5f0f\u7684\u4f18\u96c5\u964d\u7ea7
\n@Service
\npublic class RecommendationService {<\/p>\nprivate final CircuitBreaker circuitBreaker;
\n private final CacheService cacheService;<\/p>\npublic RecommendationService() {
\n \/\/ \u914d\u7f6e\u65ad\u8def\u5668：10\u79d2\u518550%\u5931\u8d25\u89e6\u53d1\u6253\u5f00\u72b6\u6001
\n CircuitBreakerConfig config = CircuitBreakerConfig.custom()
\n .failureRateThreshold(50)
\n .waitDurationInOpenState(Duration.ofSeconds(30))
\n .slidingWindowSize(10)
\n .build();<\/p>\nthis.circuitBreaker = CircuitBreaker.of("recommendation-service", config);
\n }<\/p>\npublic List<Product> getRecommendations(String userId) {
\n return circuitBreaker.executeSupplier(() -> {
\n \/\/ \u4e3b\u903b\u8f91：\u8c03\u7528\u63a8\u8350\u5f15\u64ce
\n return callRecommendationEngine(userId);
\n }, throwable -> {
\n \/\/ \u964d\u7ea7\u903b\u8f91：\u8fd4\u56de\u7f13\u5b58\u6216\u9ed8\u8ba4\u63a8\u8350
\n logger.warn("Recommendation engine failed, using fallback", throwable);
\n return getCachedRecommendations(userId);
\n });
\n }<\/p>\nprivate List<Product> getCachedRecommendations(String userId) {
\n \/\/ \u4ece\u7f13\u5b58\u83b7\u53d6\u6216\u8fd4\u56de\u9ed8\u8ba4\u5217\u8868
\n List<Product> cached = cacheService.get("rec:" + userId);
\n return cached != null ? cached : getDefaultRecommendations();
\n }
\n}<\/p>\n24.4.2 \u5168\u9762\u76d1\u63a7\u4e0e\u544a\u8b66\u4f53\u7cfb<\/h5>\n
Prometheus + Grafana\u76d1\u63a7\u914d\u7f6e\u793a\u4f8b：<\/p>\n
yaml<\/p>\n
# prometheus.yml – 500\u9519\u8bef\u76d1\u63a7\u914d\u7f6e
\nscrape_configs:
\n – job_name: 'webapp'
\n static_configs:
\n – targets: ['localhost:8080']<\/p>\n# \u81ea\u5b9a\u4e49500\u9519\u8bef\u6307\u6807
\n metric_relabel_configs:
\n – source_labels: [code]
\n regex: '5..'
\n action: keep<\/p>\n# \u544a\u8b66\u89c4\u5219\u914d\u7f6e
\ngroups:
\n – name: http_errors
\n rules:
\n – alert: High500ErrorRate
\n expr: |
\n rate(
\n http_requests_total{status="500"}[5m]
\n ) \/ rate(
\n http_requests_total[5m]
\n ) > 0.05 # 5%\u7684500\u9519\u8bef\u7387
\n for: 2m
\n labels:
\n severity: critical
\n annotations:
\n summary: "High rate of 500 errors detected"
\n description: |
\n 500\u9519\u8bef\u7387\u8d85\u8fc75%，\u5f53\u524d\u503c: {{ $value }}
\n \u5f71\u54cd\u670d\u52a1: {{ $labels.service }}<\/p>\n24.4.3 \u81ea\u52a8\u5316\u6062\u590d\u673a\u5236<\/h5>\n
Kubernetes\u5065\u5eb7\u68c0\u67e5\u4e0e\u81ea\u6108：<\/p>\n
yaml<\/p>\n
# deployment.yaml
\napiVersion: apps\/v1
\nkind: Deployment
\nmetadata:
\n name: webapp-deployment
\nspec:
\n replicas: 3
\n selector:
\n matchLabels:
\n app: webapp
\n template:
\n metadata:
\n labels:
\n app: webapp
\n spec:
\n containers:
\n – name: webapp
\n image: your-webapp:latest
\n ports:
\n – containerPort: 8080<\/p>\n# \u6d3b\u6027\u63a2\u9488 – \u68c0\u67e5\u5bb9\u5668\u662f\u5426\u5b58\u6d3b
\n livenessProbe:
\n httpGet:
\n path: \/health\/live
\n port: 8080
\n initialDelaySeconds: 30
\n periodSeconds: 10
\n failureThreshold: 3 # \u8fde\u7eed3\u6b21\u5931\u8d25\u540e\u91cd\u542f\u5bb9\u5668<\/p>\n# \u5c31\u7eea\u63a2\u9488 – \u68c0\u67e5\u5bb9\u5668\u662f\u5426\u51c6\u5907\u597d\u63a5\u6536\u6d41\u91cf
\n readinessProbe:
\n httpGet:
\n path: \/health\/ready
\n port: 8080
\n initialDelaySeconds: 5
\n periodSeconds: 5
\n failureThreshold: 2<\/p>\n# \u8d44\u6e90\u9650\u5236\u9632\u6b62OOM
\n resources:
\n limits:
\n memory: "512Mi"
\n cpu: "500m"
\n requests:
\n memory: "256Mi"
\n cpu: "250m"<\/p>\n24.5 \u9884\u9632\u6027\u67b6\u6784\u8bbe\u8ba1<\/h4>\n
24.5.1 \u5bb9\u9519\u67b6\u6784\u6a21\u5f0f<\/h5>\n
\u5fae\u670d\u52a1\u67b6\u6784\u4e2d\u7684\u9519\u8bef\u4f20\u64ad\u63a7\u5236：<\/p>\n
python<\/p>\n
# \u4f7f\u7528\u5f02\u6b65\u6d88\u606f\u961f\u5217\u89e3\u8026\u670d\u52a1
\nimport asyncio
\nfrom contextlib import asynccontextmanager
\nfrom typing import Optional<\/p>\nclass ResilientService:
\n def __init__(self):
\n self.retry_policy = ExponentialBackoffRetry(
\n max_retries=3,
\n base_delay=1.0,
\n max_delay=10.0
\n )<\/p>\nasync def process_with_retry(self, task, task_id: str):
\n """\u5e26\u91cd\u8bd5\u548c\u6b7b\u4fe1\u961f\u5217\u7684\u5904\u7406"""
\n for attempt in range(self.retry_policy.max_retries):
\n try:
\n return await task()<\/p>\nexcept TransientError as e:
\n if attempt == self.retry_policy.max_retries – 1:
\n # \u6700\u7ec8\u5931\u8d25，\u8fdb\u5165\u6b7b\u4fe1\u961f\u5217
\n await self.send_to_dead_letter_queue(task_id, str(e))
\n raise<\/p>\ndelay = self.retry_policy.get_delay(attempt)
\n logger.warning(f"Attempt {attempt+1} failed, retrying in {delay}s")
\n await asyncio.sleep(delay)<\/p>\nexcept PermanentError as e:
\n # \u6c38\u4e45\u6027\u9519\u8bef，\u4e0d\u91cd\u8bd5
\n logger.error(f"Permanent error: {str(e)}")
\n await self.send_to_dead_letter_queue(task_id, str(e))
\n raise<\/p>\n24.5.2 \u6df7\u6c8c\u5de5\u7a0b\u4e0e\u97e7\u6027\u6d4b\u8bd5<\/h5>\n
python<\/p>\n
# \u4f7f\u7528Chaos Toolkit\u8fdb\u884c\u6545\u969c\u6ce8\u5165\u6d4b\u8bd5
\nimport chaos
\nfrom chaos import experiment<\/p>\n@experiment
\ndef test_database_failure_resilience():
\n """\u6d4b\u8bd5\u6570\u636e\u5e93\u6545\u969c\u65f6\u7684\u670d\u52a1\u884c\u4e3a"""<\/p>\n# 1. \u5efa\u7acb\u5065\u5eb7\u57fa\u51c6
\n baseline = get_system_health()<\/p>\n# 2. \u6ce8\u5165\u6545\u969c：\u6a21\u62df\u6570\u636e\u5e93\u8fde\u63a5\u5931\u8d25
\n with chaos.inject_fault(
\n target="database",
\n fault_type="network_latency",
\n parameters={"latency": 5000, "duration": "30s"}
\n ):
\n # 3. \u76d1\u63a7\u7cfb\u7edf\u54cd\u5e94
\n response = simulate_user_workflow()<\/p>\n# 4. \u9a8c\u8bc1\u7cfb\u7edf\u662f\u5426\u4f18\u96c5\u964d\u7ea7
\n assert response.status_code != 500, "\u7cfb\u7edf\u4e0d\u5e94\u8fd4\u56de500\u9519\u8bef"
\n assert has_fallback_content(response), "\u5e94\u663e\u793a\u964d\u7ea7\u5185\u5bb9"<\/p>\n# 5. \u6536\u96c6\u6307\u6807
\n metrics = collect_performance_metrics()<\/p>\n# 6. \u6062\u590d\u5e76\u9a8c\u8bc1
\n recovery_time = measure_recovery_time()
\n assert recovery_time < 60, "\u6062\u590d\u65f6\u95f4\u5e94\u5c0f\u4e8e60\u79d2"<\/p>\nreturn {
\n "baseline": baseline,
\n "under_fault": metrics,
\n "recovery_time": recovery_time
\n }<\/p>\n24.6 \u603b\u7ed3：\u4ece\u88ab\u52a8\u54cd\u5e94\u5230\u4e3b\u52a8\u9884\u9632<\/h4>\n
500 Internal Server Error \u867d\u7136\u662f\u4e00\u4e2a\u901a\u7528\u9519\u8bef，\u4f46\u5176\u80cc\u540e\u7684\u539f\u56e0\u5343\u5dee\u4e07\u522b\u3002\u6709\u6548\u7684500\u9519\u8bef\u7ba1\u7406\u9700\u8981：<\/p>\n
- \n
\u591a\u5c42\u9632\u5fa1\u4f53\u7cfb：\u4ece\u4ee3\u7801\u7ea7\u5f02\u5e38\u5904\u7406\u5230\u67b6\u6784\u7ea7\u5bb9\u9519\u8bbe\u8ba1<\/p>\n<\/li>\n
- \n
\u5168\u9762\u53ef\u89c2\u6d4b\u6027：\u65e5\u5fd7\u3001\u6307\u6807\u3001\u8ffd\u8e2a\u4e09\u4f4d\u4e00\u4f53\u7684\u76d1\u63a7\u4f53\u7cfb<\/p>\n<\/li>\n
- \n
\u81ea\u52a8\u5316\u6062\u590d：\u57fa\u4e8e\u5065\u5eb7\u68c0\u67e5\u7684\u81ea\u52a8\u91cd\u542f\u548c\u6d41\u91cf\u5207\u6362<\/p>\n<\/li>\n
- \n
\u9884\u9632\u6027\u6d4b\u8bd5：\u6df7\u6c8c\u5de5\u7a0b\u3001\u8d1f\u8f7d\u6d4b\u8bd5\u3001\u6545\u969c\u6ce8\u5165<\/p>\n<\/li>\n
- \n
\u6301\u7eed\u6539\u8fdb：\u5efa\u7acb\u6545\u969c\u590d\u76d8\u6587\u5316，\u5c06\u6bcf\u6b21500\u9519\u8bef\u8f6c\u5316\u4e3a\u7cfb\u7edf\u52a0\u56fa\u7684\u673a\u4f1a<\/p>\n<\/li>\n
\u901a\u8fc7\u7cfb\u7edf\u5316\u7684\u65b9\u6cd5\u5904\u7406500\u9519\u8bef，\u53ef\u4ee5\u663e\u8457\u63d0\u5347\u7cfb\u7edf\u7684\u53ef\u7528\u6027\u548c\u53ef\u9760\u6027，\u5c06\u4e0d\u53ef\u9884\u77e5\u7684\u670d\u52a1\u5668\u9519\u8bef\u8f6c\u5316\u4e3a\u53ef\u7ba1\u7406\u3001\u53ef\u9884\u9632\u7684\u7cfb\u7edf\u884c\u4e3a\u3002<\/p>\n
\n\u7b2c25\u7ae0：501 Not Implemented – \u672a\u5b9e\u73b0\u529f\u80fd<\/h3>\n
25.1 \u534f\u8bae\u89c4\u8303\u6df1\u5ea6\u89e3\u8bfb<\/h4>\n
501 Not Implemented\u00a0\u662f\u4e00\u4e2a\u7ecf\u5e38\u88ab\u8bef\u89e3\u6216\u8bef\u7528\u7684HTTP\u72b6\u6001\u7801\u3002\u5b83\u660e\u786e\u8868\u793a\u670d\u52a1\u5668\u4e0d\u652f\u6301\u5b8c\u6210\u8bf7\u6c42\u6240\u9700\u7684\u529f\u80fd\u3002<\/p>\n
25.1.1 RFC 7231 \u6b63\u5f0f\u5b9a\u4e49<\/h5>\n
- \n
- \n
\u539f\u6587："The server does not support the functionality required to fulfill the request."<\/p>\n<\/li>\n
- \n
\u5173\u952e\u89e3\u8bfb：<\/p>\n
- \n
- \n
\u670d\u52a1\u5668\u7406\u89e3\u8bf7\u6c42，\u4f46\u65e0\u6cd5\u6267\u884c<\/p>\n<\/li>\n
- \n
\u901a\u5e38\u4e0eHTTP\u65b9\u6cd5\u76f8\u5173（\u5982\u670d\u52a1\u5668\u4e0d\u652f\u6301PATCH\u65b9\u6cd5）<\/p>\n<\/li>\n
- \n
\u662f\u6c38\u4e45\u6027\u9519\u8bef，\u9664\u975e\u670d\u52a1\u5668\u5347\u7ea7<\/p>\n<\/li>\n
- \n
\u5fc5\u987b\u5305\u542b\u9002\u5f53\u7684Allow\u5934\u90e8（\u5982\u679c\u9002\u7528）<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
25.1.2 \u4e0e405 Method Not Allowed\u7684\u533a\u522b
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/07\/20260726181656-6a664f18606e1.png\")
<\/h5>\n25.2 \u5b9e\u9645\u5e94\u7528\u573a\u666f\u5206\u6790<\/h4>\n
25.2.1 REST API\u8bbe\u8ba1\u4e2d\u7684\u6b63\u786e\u4f7f\u7528<\/h5>\n
python<\/p>\n
# Flask REST API\u793a\u4f8b – \u6b63\u786e\u5b9e\u73b0501\u54cd\u5e94
\nfrom flask import Flask, jsonify, request
\nfrom functools import wraps<\/p>\napp = Flask(__name__)<\/p>\n
def require_feature(feature_name):
\n """\u88c5\u9970\u5668：\u68c0\u67e5\u529f\u80fd\u662f\u5426\u5df2\u5b9e\u73b0"""
\n def decorator(f):
\n @wraps(f)
\n def decorated_function(*args, **kwargs):
\n if not is_feature_enabled(feature_name):
\n # \u8fd4\u56de501，\u8868\u793a\u529f\u80fd\u672a\u5b9e\u73b0
\n return jsonify({
\n "error": "Feature not implemented",
\n "feature": feature_name,
\n "documentation": "https:\/\/api.example.com\/docs\/features"
\n }), 501
\n return f(*args, **kwargs)
\n return decorated_function
\n return decorator<\/p>\n@app.route('\/api\/v1\/users\/<user_id>', methods=['GET', 'PATCH', 'DELETE'])
\ndef user_operations(user_id):
\n if request.method == 'PATCH':
\n # PATCH\u65b9\u6cd5\u5df2\u8ba1\u5212\u4f46\u672a\u5b9e\u73b0
\n return jsonify({
\n "error": "PATCH method not yet implemented",
\n "message": "Use PUT for full updates or check roadmap",
\n "roadmap": "https:\/\/api.example.com\/roadmap#patch-support",
\n "available_methods": ["GET", "PUT", "DELETE"]
\n }), 501<\/p>\nelif request.method == 'DELETE':
\n if not is_deletion_enabled():
\n return jsonify({
\n "error": "User deletion not implemented",
\n "message": "Contact admin for account deletion",
\n "contact": "support@example.com"
\n }), 501<\/p>\n# \u6b63\u5e38\u5904\u7406GET\u548c\u5df2\u5b9e\u73b0\u7684DELETE
\n return handle_user_request(user_id, request.method)<\/p>\n# \u4e3aOPTIONS\u8bf7\u6c42\u6b63\u786e\u8fd4\u56deAllow\u5934\u90e8
\n@app.route('\/api\/v1\/users\/<user_id>', methods=['OPTIONS'])
\ndef user_options(user_id):
\n response = jsonify({})
\n response.headers['Allow'] = 'GET, PUT, DELETE' # \u4e0d\u5305\u62ecPATCH
\n response.headers['Accept-Patch'] = 'application\/json-patch+json'
\n return response<\/p>\n25.2.2 WebDAV\u6269\u5c55\u534f\u8bae\u573a\u666f<\/h5>\n
http<\/p>\n
# WebDAV\u5ba2\u6237\u7aef\u8bf7\u6c42\u793a\u4f8b
\nPROPFIND \/remote.php\/dav\/files\/user\/documents\/ HTTP\/1.1
\nHost: cloud.example.com
\nDepth: 1
\nContent-Type: application\/xml; charset=utf-8
\nContent-Length: 173<\/p>\n<?xml version="1.0" encoding="utf-8" ?>
\n<D:propfind xmlns:D="DAV:">
\n <D:prop>
\n <D:getlastmodified\/>
\n <D:getcontentlength\/>
\n <D:creationdate\/>
\n <D:resourcetype\/>
\n <\/D:prop>
\n<\/D:propfind><\/p>\n# \u670d\u52a1\u5668\u54cd\u5e94（\u5982\u679cPROPFIND\u672a\u5b9e\u73b0）
\nHTTP\/1.1 501 Not Implemented
\nAllow: GET, HEAD, POST, PUT, DELETE, OPTIONS
\nContent-Type: application\/json<\/p>\n{
\n "error": "PROPFIND method not supported",
\n "supported_methods": ["GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS"],
\n "webdav_support": false,
\n "alternative": "\/api\/v2\/files\/metadata"
\n}<\/p>\n25.3 \u4f01\u4e1a\u7ea7\u89e3\u51b3\u65b9\u6848\u8bbe\u8ba1<\/h4>\n
25.3.1 API\u7248\u672c\u7ba1\u7406\u4e0e\u529f\u80fd\u6807\u8bb0<\/h5>\n
yaml<\/p>\n
# OpenAPI 3.0\u89c4\u8303\u4e2d\u7684\u529f\u80fd\u6807\u8bb0
\nopenapi: 3.0.3
\ninfo:
\n title: User Management API
\n version: 1.5.0
\n description: |
\n \u6ce8\u610f：\u67d0\u4e9b\u529f\u80fd\u53ef\u80fd\u5904\u4e8ebeta\u72b6\u6001\u6216\u672a\u5b8c\u5168\u5b9e\u73b0\u3002
\n \u4f7f\u7528`X-Feature-Flags`\u5934\u90e8\u8bf7\u6c42\u7279\u5b9a\u529f\u80fd\u3002<\/p>\npaths:
\n \/users\/{id}:
\n patch:
\n summary: Partially update a user
\n description: |
\n \u6b64\u529f\u80fd\u5f53\u524d\u4e3a**\u5b9e\u9a8c\u6027**\u3002
\n \u9700\u8981\u8bbe\u7f6e`X-Feature-Flags: partial-update`\u3002
\n \u5b8c\u6574\u5b9e\u73b0\u8ba1\u5212\u5728v2.0.0\u3002
\n operationId: patchUser
\n parameters:
\n – name: X-Feature-Flags
\n in: header
\n required: true
\n schema:
\n type: string
\n enum: [partial-update]
\n responses:
\n '200':
\n description: Successfully updated
\n '501':
\n description: |
\n PATCH not fully implemented for this resource.
\n Current support limited to email field only.
\n Full PATCH support coming in v2.0.0.
\n content:
\n application\/json:
\n schema:
\n $ref: '#\/components\/schemas\/NotImplementedError'<\/p>\n25.3.2 \u6e10\u8fdb\u5f0f\u529f\u80fd\u53d1\u5e03\u7b56\u7565<\/h5>\n
python<\/p>\n
# \u529f\u80fd\u6807\u8bb0\u4e0e\u6e10\u8fdb\u5f0f\u53d1\u5e03\u7cfb\u7edf
\nfrom typing import Dict, Optional
\nfrom enum import Enum
\nimport redis<\/p>\nclass FeatureStatus(Enum):
\n NOT_IMPLEMENTED = "not_implemented"
\n ALPHA = "alpha"
\n BETA = "beta"
\n GA = "general_availability"
\n DEPRECATED = "deprecated"<\/p>\nclass FeatureManager:
\n def __init__(self):
\n self.redis = redis.Redis(host='localhost', port=6379, db=0)
\n self.feature_registry = self._load_feature_registry()<\/p>\ndef _load_feature_registry(self) -> Dict:
\n """\u52a0\u8f7d\u529f\u80fd\u5b9a\u4e49"""
\n return {
\n "user_partial_update": {
\n "status": FeatureStatus.BETA,
\n "description": "PATCH support for user resources",
\n "since_version": "1.4.0",
\n "planned_ga": "2.0.0",
\n "required_headers": ["X-Feature-Flags"],
\n "documentation": "\/docs\/features\/partial-update"
\n },
\n "bulk_operations": {
\n "status": FeatureStatus.NOT_IMPLEMENTED,
\n "description": "Bulk create\/update\/delete operations",
\n "planned_version": "2.1.0",
\n "roadmap_url": "\/roadmap#bulk-operations"
\n }
\n }<\/p>\ndef check_feature_access(self, feature_name: str,
\n user_id: Optional[str] = None) -> bool:
\n """\u68c0\u67e5\u7528\u6237\u662f\u5426\u53ef\u4ee5\u8bbf\u95ee\u7279\u5b9a\u529f\u80fd"""
\n feature = self.feature_registry.get(feature_name)<\/p>\nif not feature:
\n return False<\/p>\nstatus = feature["status"]<\/p>\n
# \u6839\u636e\u529f\u80fd\u72b6\u6001\u51b3\u5b9a\u8bbf\u95ee\u6743\u9650
\n if status == FeatureStatus.NOT_IMPLEMENTED:
\n return False
\n elif status == FeatureStatus.ALPHA:
\n # \u4ec5\u9650\u5185\u90e8\u6d4b\u8bd5\u7528\u6237
\n return self._is_internal_user(user_id)
\n elif status == FeatureStatus.BETA:
\n # Beta\u6d4b\u8bd5\u7528\u6237\u6216\u901a\u8fc7\u529f\u80fd\u6807\u8bb0\u8bf7\u6c42
\n return self._is_beta_user(user_id) or self._has_feature_flag(feature_name)
\n elif status == FeatureStatus.GA:
\n return True
\n elif status == FeatureStatus.DEPRECATED:
\n # \u5df2\u5f03\u7528\u529f\u80fd\u53ef\u80fd\u4ecd\u7136\u53ef\u7528
\n return self._has_legacy_access(user_id)<\/p>\nreturn False<\/p>\n
def handle_not_implemented(self, feature_name: str, request) -> tuple:
\n """\u751f\u6210\u6807\u51c6\u5316\u7684501\u54cd\u5e94"""
\n feature = self.feature_registry.get(feature_name, {})<\/p>\nresponse_data = {
\n "error": "Feature not implemented",
\n "feature": feature_name,
\n "current_status": feature.get("status", "unknown"),
\n "message": feature.get("description", "")
\n }<\/p>\n# \u6dfb\u52a0\u6709\u7528\u7684\u5143\u6570\u636e
\n if "planned_version" in feature:
\n response_data["planned_release"] = feature["planned_version"]
\n if "documentation" in feature:
\n response_data["documentation_url"] = f"https:\/\/api.example.com{feature['documentation']}"
\n if "roadmap_url" in feature:
\n response_data["roadmap_url"] = f"https:\/\/api.example.com{feature['roadmap_url']}"<\/p>\n# \u6839\u636e\u8bf7\u6c42Accept\u5934\u90e8\u8fd4\u56de\u4e0d\u540c\u683c\u5f0f
\n accept_header = request.headers.get('Accept', 'application\/json')
\n if 'text\/html' in accept_header:
\n return self._render_feature_roadmap_html(feature_name), 501
\n elif 'application\/xml' in accept_header:
\n return self._render_feature_roadmap_xml(feature_name), 501
\n else:
\n return jsonify(response_data), 501<\/p>\n25.4 \u5ba2\u6237\u7aef\u5904\u7406\u7b56\u7565<\/h4>\n
25.4.1 \u4f18\u96c5\u7684\u529f\u80fd\u68c0\u6d4b\u4e0e\u964d\u7ea7<\/h5>\n
javascript<\/p>\n
\/\/ \u73b0\u4ee3JavaScript\u5ba2\u6237\u7aef\u5b9e\u73b0
\nclass APIClient {
\n constructor(baseURL) {
\n this.baseURL = baseURL;
\n this.capabilities = new Map();
\n this.featureDetectionDone = false;
\n }<\/p>\nasync detectCapabilities() {
\n try {
\n \/\/ \u9996\u5148\u5c1d\u8bd5OPTIONS\u8bf7\u6c42\u83b7\u53d6\u652f\u6301\u7684\u65b9\u6cd5
\n const optionsResponse = await fetch(`${this.baseURL}\/api\/v1`, {
\n method: 'OPTIONS'
\n });<\/p>\nif (optionsResponse.headers.has('Allow')) {
\n const allowedMethods = optionsResponse.headers.get('Allow')
\n .split(',')
\n .map(m => m.trim());<\/p>\nthis.capabilities.set('methods', allowedMethods);
\n }<\/p>\n\/\/ \u68c0\u67e5\u7279\u5b9a\u529f\u80fd
\n await this.checkFeature('partial-update');
\n await this.checkFeature('bulk-operations');<\/p>\nthis.featureDetectionDone = true;
\n this.saveCapabilitiesToStorage();<\/p>\n} catch (error) {
\n console.warn('Capability detection failed, using defaults', error);
\n this.setDefaultCapabilities();
\n }
\n }<\/p>\nasync checkFeature(featureName) {
\n const testEndpoint = `${this.baseURL}\/api\/v1\/feature-check\/${featureName}`;<\/p>\ntry {
\n const response = await fetch(testEndpoint, {
\n method: 'HEAD',
\n headers: {
\n 'X-Feature-Check': 'true'
\n }
\n });<\/p>\nif (response.status === 200) {
\n this.capabilities.set(featureName, true);<\/p>\n\/\/ \u5982\u679c\u6709\u529f\u80fd\u7248\u672c\u4fe1\u606f
\n const version = response.headers.get('X-Feature-Version');
\n if (version) {
\n this.capabilities.set(`${featureName}.version`, version);
\n }
\n } else if (response.status === 501) {
\n this.capabilities.set(featureName, false);<\/p>\n\/\/ \u89e3\u6790\u54cd\u5e94\u83b7\u53d6\u66f4\u591a\u4fe1\u606f
\n const errorData = await response.json();
\n this.capabilities.set(`${featureName}.info`, errorData);
\n }
\n } catch (error) {
\n \/\/ \u7f51\u7edc\u9519\u8bef，\u529f\u80fd\u72b6\u6001\u672a\u77e5
\n this.capabilities.set(featureName, 'unknown');
\n }
\n }<\/p>\nasync updateUser(userId, data, partial = false) {
\n \/\/ \u6839\u636e\u529f\u80fd\u652f\u6301\u60c5\u51b5\u9009\u62e9\u65b9\u6cd5
\n if (partial && this.capabilities.get('partial-update')) {
\n try {
\n return await this.patchUser(userId, data);
\n } catch (error) {
\n if (error.status === 501) {
\n \/\/ \u529f\u80fd\u68c0\u6d4b\u53ef\u80fd\u8fc7\u65f6，\u66f4\u65b0\u5e76\u964d\u7ea7
\n await this.detectCapabilities();
\n return await this.putUser(userId, data);
\n }
\n throw error;
\n }
\n } else {
\n \/\/ \u4f7f\u7528\u5b8c\u6574\u7684PUT\u66f4\u65b0
\n return await this.putUser(userId, data);
\n }
\n }<\/p>\nasync patchUser(userId, data) {
\n const response = await fetch(`${this.baseURL}\/api\/v1\/users\/${userId}`, {
\n method: 'PATCH',
\n headers: {
\n 'Content-Type': 'application\/json-patch+json',
\n 'X-Feature-Flags': 'partial-update'
\n },
\n body: JSON.stringify(data)
\n });<\/p>\nif (response.status === 501) {
\n const error = new Error('Partial update not implemented');
\n error.status = 501;
\n error.details = await response.json();
\n throw error;
\n }<\/p>\nreturn response.json();
\n }
\n}<\/p>\n25.4.2 \u7528\u6237\u754c\u9762\u7684\u4f18\u96c5\u5904\u7406<\/h5>\n
vue<\/p>\n
<!– Vue.js\u7ec4\u4ef6：\u529f\u80fd\u4e0d\u53ef\u7528\u7684\u4f18\u96c5UI\u5904\u7406 –>
\n<template>
\n <div class="feature-unavailable">
\n <div v-if="isLoading" class="loading">
\n <span class="spinner"><\/span>
\n \u68c0\u67e5\u529f\u80fd\u53ef\u7528\u6027…
\n <\/div><\/p>\n<div v-else-if="!isSupported" class="unsupported-feature">
\n <div class="feature-header">
\n <icon name="construction" size="48" \/>
\n <h2>{{ featureName }} \u529f\u80fd\u6682\u65f6\u4e0d\u53ef\u7528<\/h2>
\n <\/div><\/p>\n<div class="feature-details">
\n <p v-if="featureInfo.message">{{ featureInfo.message }}<\/p><\/p>\n<div v-if="featureInfo.planned_release" class="roadmap-info">
\n <h3>\u8ba1\u5212\u53d1\u5e03\u7248\u672c<\/h3>
\n <p>\u9884\u8ba1\u5728 <strong>{{ featureInfo.planned_release }}<\/strong> \u7248\u672c\u4e2d\u63d0\u4f9b<\/p>
\n <a :href="featureInfo.roadmap_url" target="_blank">\u67e5\u770b\u8be6\u7ec6\u8def\u7ebf\u56fe<\/a>
\n <\/div><\/p>\n<div v-if="hasAlternatives" class="alternatives">
\n <h3>\u66ff\u4ee3\u65b9\u6848<\/h3>
\n <ul>
\n <li v-for="alt in alternatives" :key="alt.method">
\n <button @click="useAlternative(alt)">
\n \u4f7f\u7528 {{ alt.name }}
\n <\/button>
\n <\/li>
\n <\/ul>
\n <\/div><\/p>\n<div class="actions">
\n <button @click="retryDetection" class="btn-secondary">
\n \u91cd\u65b0\u68c0\u67e5\u529f\u80fd
\n <\/button>
\n <a :href="featureInfo.documentation_url"
\n target="_blank"
\n class="btn-primary">
\n \u67e5\u770b\u6587\u6863
\n <\/a>
\n <\/div>
\n <\/div>
\n <\/div><\/p>\n<slot v-else><\/slot>
\n <\/div>
\n<\/template><\/p>\n<script>
\nexport default {
\n name: 'FeatureGuard',
\n props: {
\n featureName: {
\n type: String,
\n required: true
\n },
\n required: {
\n type: Boolean,
\n default: false
\n }
\n },<\/p>\ndata() {
\n return {
\n isLoading: true,
\n isSupported: false,
\n featureInfo: {},
\n alternatives: []
\n };
\n },<\/p>\nasync created() {
\n await this.checkFeatureSupport();
\n },<\/p>\nmethods: {
\n async checkFeatureSupport() {
\n this.isLoading = true;<\/p>\ntry {
\n const response = await this.$api.checkFeature(this.featureName);<\/p>\nif (response.supported) {
\n this.isSupported = true;
\n } else {
\n this.featureInfo = response.details || {};
\n this.findAlternatives();
\n }
\n } catch (error) {
\n console.error('Feature check failed:', error);
\n \/\/ \u9ed8\u8ba4\u964d\u7ea7\u5904\u7406
\n this.findAlternatives();
\n } finally {
\n this.isLoading = false;
\n }
\n },<\/p>\nfindAlternatives() {
\n \/\/ \u6839\u636e\u529f\u80fd\u540d\u67e5\u627e\u66ff\u4ee3\u65b9\u6848
\n const alternativeMap = {
\n 'partial-update': [
\n { name: '\u5b8c\u6574\u66f4\u65b0', method: 'fullUpdate' },
\n { name: '\u8868\u5355\u7f16\u8f91', method: 'formEdit' }
\n ],
\n 'bulk-operations': [
\n { name: '\u5355\u4e2a\u64cd\u4f5c', method: 'singleOperation' },
\n { name: '\u5bfc\u5165\/\u5bfc\u51fa', method: 'importExport' }
\n ]
\n };<\/p>\nthis.alternatives = alternativeMap[this.featureName] || [];
\n },<\/p>\nuseAlternative(alternative) {
\n this.$emit('use-alternative', alternative.method);
\n },<\/p>\nasync retryDetection() {
\n await this.checkFeatureSupport();
\n }
\n }
\n};
\n<\/script><\/p>\n25.5 \u76d1\u63a7\u4e0e\u6f14\u8fdb\u7ba1\u7406<\/h4>\n
25.5.1 \u529f\u80fd\u4f7f\u7528\u7387\u8ffd\u8e2a<\/h5>\n
python<\/p>\n
# \u529f\u80fd\u4f7f\u7528\u7387\u76d1\u63a7\u7cfb\u7edf
\nfrom dataclasses import dataclass
\nfrom datetime import datetime
\nfrom collections import defaultdict
\nimport statistics
\nfrom typing import Dict, List, Optional<\/p>\n@dataclass
\nclass FeatureMetric:
\n """\u529f\u80fd\u4f7f\u7528\u6307\u6807"""
\n feature_name: str
\n requests_total: int = 0
\n requests_successful: int = 0
\n requests_failed: int = 0
\n requests_not_implemented: int = 0
\n average_response_time: float = 0.0
\n p95_response_time: float = 0.0<\/p>\n@property
\n def success_rate(self) -> float:
\n if self.requests_total == 0:
\n return 0.0
\n return self.requests_successful \/ self.requests_total<\/p>\n@property
\n def not_implemented_rate(self) -> float:
\n if self.requests_total == 0:
\n return 0.0
\n return self.requests_not_implemented \/ self.requests_total<\/p>\nclass FeatureAnalytics:
\n def __init__(self):
\n self.metrics: Dict[str, FeatureMetric] = defaultdict(FeatureMetric)
\n self.response_times: Dict[str, List[float]] = defaultdict(list)
\n self.daily_requests: Dict[str, Dict[str, int]] = defaultdict(
\n lambda: defaultdict(int)
\n )<\/p>\ndef track_request(self, feature_name: str, status_code: int,
\n response_time: float):
\n """\u8ffd\u8e2a\u529f\u80fd\u8bf7\u6c42"""
\n metric = self.metrics[feature_name]
\n metric.feature_name = feature_name
\n metric.requests_total += 1<\/p>\nif 200 <= status_code < 300:
\n metric.requests_successful += 1
\n elif status_code == 501:
\n metric.requests_not_implemented += 1
\n else:
\n metric.requests_failed += 1<\/p>\n# \u8bb0\u5f55\u54cd\u5e94\u65f6\u95f4
\n self.response_times[feature_name].append(response_time)<\/p>\n# \u66f4\u65b0\u7edf\u8ba1
\n times = self.response_times[feature_name]
\n if times:
\n metric.average_response_time = statistics.mean(times)
\n if len(times) >= 5:
\n metric.p95_response_time = statistics.quantiles(times, n=20)[18]<\/p>\n# \u8bb0\u5f55\u6bcf\u65e5\u8bf7\u6c42
\n today = datetime.now().strftime('%Y-%m-%d')
\n self.daily_requests[feature_name][today] += 1<\/p>\ndef get_feature_priority_score(self, feature_name: str) -> float:
\n """\u8ba1\u7b97\u529f\u80fd\u5b9e\u73b0\u7684\u4f18\u5148\u7ea7\u5206\u6570"""
\n metric = self.metrics.get(feature_name)
\n if not metric or metric.requests_total == 0:
\n return 0.0<\/p>\n# \u57fa\u4e8e\u8bf7\u6c42\u91cf\u3001\u5931\u8d25\u7387\u548c\u4e1a\u52a1\u91cd\u8981\u6027\u8ba1\u7b97\u5206\u6570
\n request_volume_score = min(metric.requests_total \/ 1000, 1.0)
\n not_implemented_score = metric.not_implemented_rate<\/p>\n# \u4e1a\u52a1\u91cd\u8981\u6027\u6743\u91cd（\u53ef\u4ece\u914d\u7f6e\u83b7\u53d6）
\n business_importance = self.get_business_importance(feature_name)<\/p>\n# \u8ba1\u7b97\u7efc\u5408\u5206\u6570
\n priority_score = (
\n request_volume_score * 0.4 +
\n not_implemented_score * 0.4 +
\n business_importance * 0.2
\n )<\/p>\nreturn priority_score<\/p>\n
def generate_roadmap_recommendations(self) -> List[Dict]:
\n """\u751f\u6210\u8def\u7ebf\u56fe\u5efa\u8bae"""
\n recommendations = []<\/p>\nfor feature_name, metric in self.metrics.items():
\n if metric.requests_not_implemented > 0:
\n score = self.get_feature_priority_score(feature_name)<\/p>\nrecommendation = {
\n 'feature': feature_name,
\n 'priority_score': round(score, 2),
\n 'total_requests': metric.requests_total,
\n 'not_implemented_requests': metric.requests_not_implemented,
\n 'not_implemented_rate': round(metric.not_implemented_rate, 3),
\n 'recommendation': self.get_implementation_recommendation(score),
\n 'estimated_effort': self.estimate_implementation_effort(feature_name)
\n }<\/p>\nrecommendations.append(recommendation)<\/p>\n
# \u6309\u4f18\u5148\u7ea7\u6392\u5e8f
\n recommendations.sort(key=lambda x: x['priority_score'], reverse=True)
\n return recommendations<\/p>\n25.6 \u6700\u4f73\u5b9e\u8df5\u603b\u7ed3<\/h4>\n
25.6.1 Do's and Don'ts<\/h5>\n
\u5e94\u8be5\u505a：<\/p>\n
- \n
- \n
\u2705 \u4e3a\u6240\u6709\u672a\u5b9e\u73b0\u7684\u529f\u80fd\u8fd4\u56de\u4e00\u81f4\u7684501\u54cd\u5e94<\/p>\n<\/li>\n
- \n
\u2705 \u5728OPTIONS\u54cd\u5e94\u4e2d\u51c6\u786e\u5217\u51fa\u652f\u6301\u7684\u65b9\u6cd5<\/p>\n<\/li>\n
- \n
\u2705 \u63d0\u4f9b\u6e05\u6670\u7684\u9519\u8bef\u4fe1\u606f\u548c\u6587\u6863\u94fe\u63a5<\/p>\n<\/li>\n
- \n
\u2705 \u4f7f\u7528\u529f\u80fd\u6807\u8bb0\u7ba1\u7406\u5b9e\u9a8c\u6027\u529f\u80fd<\/p>\n<\/li>\n
- \n
\u2705 \u8ffd\u8e2a501\u9519\u8bef\u7387\u4ee5\u6307\u5bfc\u4ea7\u54c1\u8def\u7ebf\u56fe<\/p>\n<\/li>\n<\/ul>\n
\u4e0d\u5e94\u8be5\u505a：<\/p>\n
- \n
- \n
\u274c \u7528501\u54cd\u5e94\u66ff\u4ee3400\u3001404\u6216405<\/p>\n<\/li>\n
- \n
\u274c \u5728\u672a\u5b9e\u73b0\u529f\u80fd\u4e0a\u4e0d\u63d0\u4f9b\u4efb\u4f55\u54cd\u5e94<\/p>\n<\/li>\n
- \n
\u274c \u6df7\u6dc6"\u672a\u5b9e\u73b0"\u548c"\u6682\u65f6\u4e0d\u53ef\u7528"（\u5e94\u8be5\u7528503）<\/p>\n<\/li>\n
- \n
\u274c \u5ffd\u7565Allow\u5934\u90e8\u7684\u51c6\u786e\u6027<\/p>\n<\/li>\n
- \n
\u274c \u4e0d\u63d0\u4f9b\u529f\u80fd\u6f14\u8fdb\u7684\u65f6\u95f4\u8868<\/p>\n<\/li>\n<\/ul>\n
25.6.2 \u6f14\u8fdb\u7b56\u7565\u5efa\u8bae<\/h5>\n
- \n
\u900f\u660e\u6c9f\u901a：\u5411\u7528\u6237\u660e\u786e\u8bf4\u660e\u529f\u80fd\u72b6\u6001\u548c\u8ba1\u5212<\/p>\n<\/li>\n
- \n
\u6e10\u8fdb\u5f0f\u53d1\u5e03：\u4f7f\u7528\u529f\u80fd\u6807\u8bb0\u63a7\u5236\u529f\u80fd\u66dd\u5149\u5ea6<\/p>\n<\/li>\n
- \n
\u53cd\u9988\u5faa\u73af：\u57fa\u4e8e501\u8bf7\u6c42\u91cf\u8c03\u6574\u5f00\u53d1\u4f18\u5148\u7ea7<\/p>\n<\/li>\n
- \n
\u5411\u540e\u517c\u5bb9：\u786e\u4fddAPI\u6f14\u8fdb\u4e0d\u5f71\u54cd\u73b0\u6709\u5ba2\u6237\u7aef<\/p>\n<\/li>\n
- \n
\u76d1\u63a7\u9a71\u52a8：\u7528\u6570\u636e\u6307\u5bfc\u529f\u80fd\u5b9e\u73b0\u51b3\u7b56<\/p>\n<\/li>\n
\u901a\u8fc7\u7cfb\u7edf\u5316\u5730\u7ba1\u7406501\u72b6\u6001\u7801，API\u53ef\u4ee5\u63d0\u4f9b\u66f4\u597d\u7684\u5f00\u53d1\u8005\u4f53\u9a8c，\u540c\u65f6\u4e3a\u4ea7\u54c1\u56e2\u961f\u63d0\u4f9b\u6709\u4ef7\u503c\u7684\u6570\u636e\u6765\u6307\u5bfc\u529f\u80fd\u5f00\u53d1\u4f18\u5148\u7ea7\u3002<\/p>\n
\n\u7b2c26\u7ae0：502 Bad Gateway – \u7f51\u5173\u9519\u8bef<\/h3>\n
26.1 \u67b6\u6784\u89c6\u89d2\u6df1\u5ea6\u89e3\u6790<\/h4>\n
502 Bad Gateway\u00a0\u662f\u5206\u5e03\u5f0f\u7cfb\u7edf\u4e2d\u5e38\u89c1\u4f46\u590d\u6742\u7684\u9519\u8bef，\u8868\u660e\u4f5c\u4e3a\u7f51\u5173\u6216\u4ee3\u7406\u7684\u670d\u52a1\u5668\u4ece\u4e0a\u6e38\u670d\u52a1\u5668\u63a5\u6536\u5230\u65e0\u6548\u54cd\u5e94\u3002<\/p>\n
26.1.1 \u7f51\u5173\u67b6\u6784\u4e2d\u7684\u89d2\u8272\u5b9a\u4f4d<\/h5>\n
text<\/p>\n
\u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
\n\u2502 \u5ba2\u6237\u7aef\u8bf7\u6c42\u6d41 \u2502
\n\u251c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
\n\u2502 1. \u5ba2\u6237\u7aef \u2192 \u8d1f\u8f7d\u5747\u8861\u5668 \u2192 \u53cd\u5411\u4ee3\u7406(Nginx) \u2192 \u5e94\u7528\u670d\u52a1\u5668 \u2502
\n\u2502 \u2191 \u2191 \u2191 \u2191 \u2502
\n\u2502 \u2502 \u2502 \u2502 \u2502 \u2502
\n\u2502 2. \u54cd\u5e94 \u2190 \u2190 502\u9519\u8bef\u53ef\u80fd\u53d1\u751f\u5728\u4efb\u610f \u2192 \u4e4b\u95f4 \u2192 \u2502
\n\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518<\/p>\n\u5e38\u89c1502\u4ea7\u751f\u70b9：
\n\u2022 \u8d1f\u8f7d\u5747\u8861\u5668 \u2194 \u53cd\u5411\u4ee3\u7406 \u901a\u4fe1\u5931\u8d25
\n\u2022 \u53cd\u5411\u4ee3\u7406 \u2194 \u5e94\u7528\u670d\u52a1\u5668 \u8fde\u63a5\u95ee\u9898
\n\u2022 \u5e94\u7528\u670d\u52a1\u5668 \u2194 \u5fae\u670d\u52a1\/API \u8c03\u7528\u8d85\u65f6
\n\u2022 \u5fae\u670d\u52a1 \u2194 \u6570\u636e\u5e93\/\u7f13\u5b58 \u8fde\u63a5\u5f02\u5e38<\/p>\n26.1.2 \u4e0e\u76f8\u5173\u9519\u8bef\u7684\u7cbe\u786e\u533a\u5206
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/07\/20260726181658-6a664f1a20358.png\")
<\/h5>\n26.2 \u751f\u4ea7\u73af\u5883\u6545\u969c\u8bca\u65ad<\/h4>\n
26.2.1 Nginx\u4f5c\u4e3a\u53cd\u5411\u4ee3\u7406\u7684\u5178\u578b\u573a\u666f<\/h5>\n
nginx<\/p>\n
# Nginx\u914d\u7f6e\u793a\u4f8b\u53ca\u6f5c\u5728\u95ee\u9898\u70b9
\nupstream backend {
\n # \u95ee\u98981：\u4e0d\u6070\u5f53\u7684\u5065\u5eb7\u68c0\u67e5
\n server 10.0.1.1:8080 max_fails=3 fail_timeout=30s;
\n server 10.0.1.2:8080 max_fails=3 fail_timeout=30s;<\/p>\n# \u5efa\u8bae\u914d\u7f6e：
\n # server 10.0.1.1:8080 max_fails=3 fail_timeout=30s slow_start=30s;
\n # server 10.0.1.2:8080 backup; # \u5907\u4efd\u670d\u52a1\u5668
\n}<\/p>\nserver {
\n listen 80;
\n server_name api.example.com;<\/p>\n# \u95ee\u98982：\u4ee3\u7406\u7f13\u51b2\u8bbe\u7f6e\u4e0d\u5f53
\n proxy_buffering on;
\n proxy_buffer_size 4k;
\n proxy_buffers 8 4k;
\n proxy_busy_buffers_size 8k;<\/p>\n# \u95ee\u98983：\u8d85\u65f6\u8bbe\u7f6e\u4e0d\u5408\u7406
\n proxy_connect_timeout 5s; # \u8fde\u63a5\u4e0a\u6e38\u8d85\u65f6
\n proxy_send_timeout 60s; # \u53d1\u9001\u8bf7\u6c42\u8d85\u65f6
\n proxy_read_timeout 60s; # \u8bfb\u53d6\u54cd\u5e94\u8d85\u65f6<\/p>\n# \u5173\u952e\u6539\u8fdb：\u542f\u7528\u8be6\u7ec6\u9519\u8bef\u65e5\u5fd7
\n error_log \/var\/log\/nginx\/502_errors.log debug;<\/p>\nlocation \/api\/ {
\n proxy_pass http:\/\/backend;<\/p>\n# \u6dfb\u52a0\u8bca\u65ad\u5934\u90e8
\n proxy_set_header X-Real-IP $remote_addr;
\n proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
\n proxy_set_header X-Forwarded-Proto $scheme;
\n proxy_set_header X-Request-ID $request_id;<\/p>\n# \u9519\u8bef\u9875\u9762\u5904\u7406
\n error_page 502 =503 \/maintenance.html;<\/p>\n# \u91cd\u8bd5\u673a\u5236
\n proxy_next_upstream error timeout invalid_header http_502;
\n proxy_next_upstream_tries 3;
\n proxy_next_upstream_timeout 10s;
\n }<\/p>\n# \u81ea\u5b9a\u4e49502\u9519\u8bef\u9875\u9762
\n location = \/maintenance.html {
\n internal;
\n root \/usr\/share\/nginx\/html;
\n }
\n}<\/p>\n26.2.2 \u7cfb\u7edf\u5316\u8bca\u65ad\u811a\u672c<\/h5>\n
bash<\/p>\n
#!\/bin\/bash
\n# 502\u9519\u8bef\u5168\u65b9\u4f4d\u8bca\u65ad\u5de5\u5177<\/p>\necho "========== 502 Bad Gateway \u8bca\u65ad\u62a5\u544a =========="
\necho "\u751f\u6210\u65f6\u95f4: $(date)"
\necho "=============================================="<\/p>\n# 1. \u7cfb\u7edf\u7ea7\u68c0\u67e5
\necho -e "\\\\n1. \u7cfb\u7edf\u8d44\u6e90\u68c0\u67e5:"
\necho "\u5185\u5b58\u4f7f\u7528:"
\nfree -h | grep -E "^(Mem|Swap)"<\/p>\necho -e "\\\\nCPU\u8d1f\u8f7d:"
\nuptime
\nmpstat -P ALL 1 1 | tail -n +4<\/p>\necho -e "\\\\n\u78c1\u76d8\u7a7a\u95f4:"
\ndf -h | grep -E "^\/dev"<\/p>\n# 2. \u7f51\u7edc\u8fde\u63a5\u68c0\u67e5
\necho -e "\\\\n2. \u7f51\u7edc\u8fde\u63a5\u72b6\u6001:"
\necho "\u8fde\u63a5\u6570\u7edf\u8ba1:"
\nss -s | head -5<\/p>\necho -e "\\\\nNginx\u8fde\u63a5\u72b6\u6001:"
\nnetstat -an | grep ':80' | awk '{print $6}' | sort | uniq -c | sort -rn<\/p>\n# 3. Nginx\u7279\u5b9a\u68c0\u67e5
\necho -e "\\\\n3. Nginx\u72b6\u6001\u68c0\u67e5:"
\nif systemctl is-active nginx >\/dev\/null 2>&1; then
\n echo "Nginx\u8fd0\u884c\u72b6\u6001: ACTIVE"<\/p>\n# \u68c0\u67e5Nginx\u9519\u8bef\u65e5\u5fd7\u4e2d\u7684502\u9519\u8bef
\n echo -e "\\\\n\u6700\u8fd1502\u9519\u8bef:"
\n tail -100 \/var\/log\/nginx\/error.log | grep -i "502" | head -10<\/p>\n# \u68c0\u67e5\u4e0a\u6e38\u670d\u52a1\u5668\u72b6\u6001
\n echo -e "\\\\n\u4e0a\u6e38\u670d\u52a1\u5668\u68c0\u67e5:"
\n upstream_servers=$(grep -r "server " \/etc\/nginx\/conf.d\/* | grep -v "#" | awk '{print $2}')
\n for server in $upstream_servers; do
\n echo -n "\u68c0\u67e5 $server … "
\n if timeout 2 nc -z ${server%:*} ${server#*:} 2>\/dev\/null; then
\n echo "\u2713 \u53ef\u8fbe"
\n else
\n echo "\u2717 \u4e0d\u53ef\u8fbe"
\n fi
\n done<\/p>\n# Nginx\u6d3b\u52a8\u8fde\u63a5
\n echo -e "\\\\nNginx\u6d3b\u52a8\u8fde\u63a5\u7edf\u8ba1:"
\n curl -s http:\/\/127.0.0.1\/nginx_status 2>\/dev\/null || \\\\
\n echo "Nginx\u72b6\u6001\u9875\u9762\u672a\u542f\u7528"
\nelse
\n echo "Nginx\u8fd0\u884c\u72b6\u6001: INACTIVE"
\nfi<\/p>\n# 4. \u5e94\u7528\u670d\u52a1\u5668\u68c0\u67e5
\necho -e "\\\\n4. \u5e94\u7528\u670d\u52a1\u5668\u68c0\u67e5:"
\ncheck_service() {
\n local service=$1
\n local port=$2<\/p>\necho -n "\u68c0\u67e5 $service (\u7aef\u53e3 $port) … "
\n if systemctl is-active $service >\/dev\/null 2>&1; then
\n echo -n "\u670d\u52a1\u6d3b\u8dc3 "
\n if ss -tln | grep ":$port " >\/dev\/null; then
\n echo "\u2713 \u76d1\u542c\u4e2d"
\n else
\n echo "\u2717 \u672a\u76d1\u542c\u7aef\u53e3"
\n fi
\n else
\n echo "\u2717 \u670d\u52a1\u672a\u8fd0\u884c"
\n fi
\n}<\/p>\n# \u5e38\u89c1\u5e94\u7528\u670d\u52a1\u5668\u68c0\u67e5
\ncheck_service "php-fpm" 9000
\ncheck_service "tomcat" 8080
\ncheck_service "node" 3000
\ncheck_service "gunicorn" 8000<\/p>\n# 5. \u9632\u706b\u5899\u68c0\u67e5
\necho -e "\\\\n5. \u9632\u706b\u5899\u89c4\u5219\u68c0\u67e5:"
\nif command -v ufw >\/dev\/null 2>&1; then
\n echo "UFW\u72b6\u6001:"
\n ufw status verbose | head -10
\nelif command -v firewall-cmd >\/dev\/null 2>&1; then
\n echo "FirewallD\u72b6\u6001:"
\n firewall-cmd –list-all | head -20
\nelse
\n echo "\u4f7f\u7528iptables:"
\n iptables -L -n | grep -E "(80|443|8080|9000)" | head -10
\nfi<\/p>\n# 6. DNS\u89e3\u6790\u68c0\u67e5
\necho -e "\\\\n6. DNS\u89e3\u6790\u68c0\u67e5:"
\nupstream_hosts=$(grep -r "proxy_pass" \/etc\/nginx\/conf.d\/* | grep -v "#" | awk '{print $2}' | cut -d'\/' -f3 | cut -d':' -f1 | sort -u)
\nfor host in $upstream_hosts; do
\n if [[ $host =~ ^[0-9]+\\\\.[0-9]+\\\\.[0-9]+\\\\.[0-9]+$ ]]; then
\n continue
\n fi
\n echo -n "\u89e3\u6790 $host … "
\n dig +short $host | head -1 | xargs echo
\ndone<\/p>\n# 7. SSL\/TLS\u68c0\u67e5（\u5982\u679c\u4f7f\u7528HTTPS）
\necho -e "\\\\n7. SSL\/TLS\u68c0\u67e5:"
\nif grep -r "ssl_certificate" \/etc\/nginx\/conf.d\/* >\/dev\/null 2>&1; then
\n echo "\u68c0\u6d4b\u5230SSL\u914d\u7f6e"
\n for cert in $(grep -r "ssl_certificate " \/etc\/nginx\/conf.d\/* | awk '{print $2}' | tr -d ';'); do
\n if [ -f "$cert" ]; then
\n echo "\u8bc1\u4e66 $cert \u6709\u6548\u671f:"
\n openssl x509 -in "$cert" -noout -dates 2>\/dev\/null || echo "\u65e0\u6548\u8bc1\u4e66"
\n fi
\n done
\nfi<\/p>\necho -e "\\\\n=============================================="
\necho "\u8bca\u65ad\u5b8c\u6210\u3002\u68c0\u67e5\u4ee5\u4e0a\u8f93\u51fa\u5bfb\u627e\u6f5c\u5728\u95ee\u9898\u3002"<\/p>\n26.3 \u9ad8\u53ef\u7528\u67b6\u6784\u89e3\u51b3\u65b9\u6848<\/h4>\n
26.3.1 \u667a\u80fd\u5065\u5eb7\u68c0\u67e5\u914d\u7f6e<\/h5>\n
yaml<\/p>\n
# Kubernetes Ingress\u5065\u5eb7\u68c0\u67e5\u914d\u7f6e\u793a\u4f8b
\napiVersion: networking.k8s.io\/v1
\nkind: Ingress
\nmetadata:
\n name: api-ingress
\n annotations:
\n # Nginx Ingress\u63a7\u5236\u5668\u914d\u7f6e
\n nginx.ingress.kubernetes.io\/upstream-hash-by: "$request_uri"
\n nginx.ingress.kubernetes.io\/load-balance: "ewma"<\/p>\n# \u5065\u5eb7\u68c0\u67e5\u914d\u7f6e
\n nginx.ingress.kubernetes.io\/health-check: "true"
\n nginx.ingress.kubernetes.io\/health-check-path: "\/health"
\n nginx.ingress.kubernetes.io\/health-check-interval: "30s"
\n nginx.ingress.kubernetes.io\/health-check-timeout: "5s"
\n nginx.ingress.kubernetes.io\/health-check-expected-statuses: "200,204"
\n nginx.ingress.kubernetes.io\/health-check-max-fails: "3"
\n nginx.ingress.kubernetes.io\/health-check-fail-timeout: "60s"<\/p>\n# \u6162\u542f\u52a8\u914d\u7f6e
\n nginx.ingress.kubernetes.io\/upstream-slow-start: "30s"<\/p>\n# \u8fde\u63a5\u7ba1\u7406
\n nginx.ingress.kubernetes.io\/upstream-keepalive-connections: "100"
\n nginx.ingress.kubernetes.io\/upstream-keepalive-timeout: "60s"
\n nginx.ingress.kubernetes.io\/upstream-keepalive-requests: "1000"<\/p>\nspec:
\n ingressClassName: nginx
\n rules:
\n – host: api.example.com
\n http:
\n paths:
\n – path: \/
\n pathType: Prefix
\n backend:
\n service:
\n name: api-service
\n port:
\n number: 8080<\/p>\n26.3.2 \u591a\u7ea7\u6545\u969c\u8f6c\u79fb\u7b56\u7565<\/h5>\n
python<\/p>\n
# Python\u7f51\u5173\u6545\u969c\u8f6c\u79fb\u5b9e\u73b0
\nimport asyncio
\nimport random
\nfrom typing import List, Optional
\nfrom dataclasses import dataclass
\nfrom enum import Enum
\nimport aiohttp
\nfrom statsd import StatsClient
\nimport redis<\/p>\nclass ServerHealth(Enum):
\n HEALTHY = "healthy"
\n UNHEALTHY = "unhealthy"
\n DEGRADED = "degraded"
\n UNKNOWN = "unknown"<\/p>\n@dataclass
\nclass UpstreamServer:
\n url: str
\n weight: int = 1
\n current_connections: int = 0
\n health: ServerHealth = ServerHealth.UNKNOWN
\n failure_count: int = 0
\n last_failure: Optional[float] = None
\n response_time_avg: float = 0.0
\n success_rate: float = 1.0<\/p>\nclass IntelligentLoadBalancer:
\n def __init__(self, upstreams: List[UpstreamServer]):
\n self.upstreams = upstreams
\n self.statsd = StatsClient()
\n self.redis = redis.Redis(host='localhost', port=6379, db=0)
\n self.circuit_breaker_threshold = 5
\n self.recovery_time = 300 # 5\u5206\u949f<\/p>\nasync def health_check(self):
\n """\u5b9a\u671f\u5065\u5eb7\u68c0\u67e5"""
\n for server in self.upstreams:
\n try:
\n async with aiohttp.ClientSession() as session:
\n start_time = asyncio.get_event_loop().time()<\/p>\nasync with session.get(
\n f"{server.url}\/health",
\n timeout=aiohttp.ClientTimeout(total=5)
\n ) as response:
\n response_time = asyncio.get_event_loop().time() – start_time<\/p>\nif response.status == 200:
\n health_data = await response.json()<\/p>\n# \u57fa\u4e8e\u54cd\u5e94\u66f4\u65b0\u670d\u52a1\u5668\u72b6\u6001
\n self.update_server_health(
\n server,
\n healthy=True,
\n response_time=response_time,
\n load=health_data.get('load', 0)
\n )
\n else:
\n self.record_failure(server)<\/p>\nexcept (aiohttp.ClientError, asyncio.TimeoutError):
\n self.record_failure(server)<\/p>\ndef record_failure(self, server: UpstreamServer):
\n """\u8bb0\u5f55\u670d\u52a1\u5668\u6545\u969c"""
\n server.failure_count += 1
\n server.last_failure = asyncio.get_event_loop().time()<\/p>\n# \u66f4\u65b0\u6210\u529f\u7387
\n total_requests = self.redis.incr(f"server:{server.url}:total")
\n failures = self.redis.incr(f"server:{server.url}:failures")
\n server.success_rate = 1 – (failures \/ total_requests)<\/p>\n# \u68c0\u67e5\u662f\u5426\u9700\u8981\u7194\u65ad
\n if server.failure_count >= self.circuit_breaker_threshold:
\n server.health = ServerHealth.UNHEALTHY
\n self.statsd.incr(f"servers.circuit_open.{server.url}")<\/p>\n# \u8bbe\u7f6e\u6062\u590d\u5b9a\u65f6\u5668
\n asyncio.create_task(self.attempt_recovery(server))<\/p>\nasync def attempt_recovery(self, server: UpstreamServer):
\n """\u5c1d\u8bd5\u6062\u590d\u6545\u969c\u670d\u52a1\u5668"""
\n await asyncio.sleep(self.recovery_time)<\/p>\n# \u534a\u5f00\u72b6\u6001\u6d4b\u8bd5
\n try:
\n async with aiohttp.ClientSession() as session:
\n async with session.get(
\n f"{server.url}\/health\/light",
\n timeout=aiohttp.ClientTimeout(total=2)
\n ) as response:
\n if response.status == 200:
\n server.failure_count = 0
\n server.health = ServerHealth.HEALTHY
\n self.statsd.incr(f"servers.circuit_closed.{server.url}")
\n except:
\n # \u6d4b\u8bd5\u5931\u8d25，\u4fdd\u6301\u7194\u65ad
\n pass<\/p>\ndef select_server(self) -> Optional[UpstreamServer]:
\n """\u667a\u80fd\u9009\u62e9\u670d\u52a1\u5668"""
\n candidates = []<\/p>\nfor server in self.upstreams:
\n # \u8df3\u8fc7\u4e0d\u5065\u5eb7\u7684\u670d\u52a1\u5668
\n if server.health == ServerHealth.UNHEALTHY:
\n continue<\/p>\n# \u6839\u636e\u6743\u91cd\u3001\u8d1f\u8f7d\u548c\u6210\u529f\u7387\u8ba1\u7b97\u9009\u62e9\u6982\u7387
\n base_weight = server.weight<\/p>\n# \u6210\u529f\u7387\u8c03\u6574（\u6210\u529f\u7387\u4f4e\u5219\u964d\u4f4e\u6743\u91cd）
\n success_adjustment = server.success_rate<\/p>\n# \u8fde\u63a5\u6570\u8c03\u6574（\u8fde\u63a5\u6570\u591a\u5219\u964d\u4f4e\u6743\u91cd）
\n connection_adjustment = 1 \/ (1 + server.current_connections * 0.1)<\/p>\n# \u54cd\u5e94\u65f6\u95f4\u8c03\u6574（\u54cd\u5e94\u6162\u5219\u964d\u4f4e\u6743\u91cd）
\n response_adjustment = 1 \/ (1 + server.response_time_avg * 0.1)<\/p>\neffective_weight = (
\n base_weight *
\n success_adjustment *
\n connection_adjustment *
\n response_adjustment
\n )<\/p>\nif effective_weight > 0:
\n candidates.append((server, effective_weight))<\/p>\nif not candidates:
\n return None<\/p>\n# \u52a0\u6743\u968f\u673a\u9009\u62e9
\n total_weight = sum(w for _, w in candidates)
\n r = random.uniform(0, total_weight)
\n cumulative = 0<\/p>\nfor server, weight in candidates:
\n cumulative += weight
\n if r <= cumulative:
\n return server<\/p>\nreturn candidates[0][0]<\/p>\n
async def proxy_request(self, request):
\n """\u4ee3\u7406\u8bf7\u6c42\u5230\u9009\u4e2d\u7684\u670d\u52a1\u5668"""
\n server = self.select_server()<\/p>\nif not server:
\n # \u6240\u6709\u670d\u52a1\u5668\u90fd\u4e0d\u53ef\u7528
\n self.statsd.incr("proxy.all_servers_unavailable")
\n return self.create_502_response()<\/p>\ntry:
\n server.current_connections += 1
\n self.statsd.incr(f"server.connections.active.{server.url}")<\/p>\n# \u8f6c\u53d1\u8bf7\u6c42
\n response = await self.forward_request(server, request)<\/p>\n# \u8bb0\u5f55\u6210\u529f
\n self.record_success(server)
\n return response<\/p>\nexcept Exception as e:
\n # \u8bb0\u5f55\u5931\u8d25
\n self.record_failure(server)
\n self.statsd.incr(f"proxy.errors.{type(e).__name__}")<\/p>\n# \u5c1d\u8bd5\u6545\u969c\u8f6c\u79fb
\n return await self.failover_request(request, server)<\/p>\nfinally:
\n server.current_connections -= 1<\/p>\nasync def failover_request(self, request, failed_server):
\n """\u6545\u969c\u8f6c\u79fb\u903b\u8f91"""
\n # \u6807\u8bb0\u539f\u59cb\u670d\u52a1\u5668\u4e3a\u6682\u65f6\u4e0d\u53ef\u7528
\n failed_server.health = ServerHealth.DEGRADED<\/p>\n# \u91cd\u8bd5\u903b\u8f91
\n for attempt in range(2): # \u6700\u591a\u91cd\u8bd52\u6b21
\n server = self.select_server()<\/p>\nif server and server != failed_server:
\n try:
\n return await self.forward_request(server, request)
\n except Exception:
\n continue<\/p>\n# \u6240\u6709\u91cd\u8bd5\u5931\u8d25
\n return self.create_502_response()<\/p>\ndef create_502_response(self):
\n """\u521b\u5efa\u6807\u51c6\u5316\u7684502\u54cd\u5e94"""
\n return {
\n "status": 502,
\n "headers": {
\n "Content-Type": "application\/json",
\n "Retry-After": "30"
\n },
\n "body": {
\n "error": {
\n "code": "bad_gateway",
\n "message": "Unable to connect to upstream server",
\n "details": {
\n "timestamp": asyncio.get_event_loop().time(),
\n "healthy_servers": len([s for s in self.upstreams
\n if s.health == ServerHealth.HEALTHY]),
\n "suggested_actions": [
\n "Please try again in 30 seconds",
\n "Check service status at status.example.com"
\n ]
\n }
\n }
\n }
\n }<\/p>\n26.4 \u76d1\u63a7\u4e0e\u544a\u8b66\u4f53\u7cfb<\/h4>\n
26.4.1 \u5168\u9762\u7684\u6307\u6807\u6536\u96c6<\/h5>\n
yaml<\/p>\n
# Prometheus\u76d1\u63a7\u914d\u7f6e
\nscrape_configs:
\n – job_name: 'nginx'
\n static_configs:
\n – targets: ['nginx:9113']<\/p>\n– job_name: 'upstream_servers'
\n static_configs:
\n – targets:
\n – 'app1:8080'
\n – 'app2:8080'
\n – 'app3:8080'
\n metrics_path: '\/metrics'<\/p>\n– job_name: 'gateway'
\n static_configs:
\n – targets: ['gateway:9090']<\/p>\n# \u544a\u8b66\u89c4\u5219
\ngroups:
\n – name: gateway_alerts
\n rules:
\n – alert: High502ErrorRate
\n expr: |
\n rate(
\n nginx_http_requests_total{status="502"}[5m]
\n ) \/ rate(
\n nginx_http_requests_total[5m]
\n ) > 0.01
\n for: 2m
\n labels:
\n severity: critical
\n component: gateway
\n annotations:
\n summary: "High rate of 502 errors"
\n description: |
\n 502\u9519\u8bef\u7387\u8d85\u8fc71%，\u5f53\u524d\u503c: {{ $value | humanizePercentage }}
\n \u53d7\u5f71\u54cd\u7684upstream: {{ $labels.upstream }}<\/p>\n– alert: UpstreamServerDown
\n expr: |
\n up{job="upstream_servers"} == 0
\n for: 1m
\n labels:
\n severity: warning
\n component: upstream
\n annotations:
\n summary: "Upstream server is down"
\n description: "{{ $labels.instance }} is not responding"<\/p>\n– alert: HighUpstreamResponseTime
\n expr: |
\n histogram_quantile(0.95,
\n rate(upstream_response_time_seconds_bucket[5m])
\n ) > 2
\n for: 5m
\n labels:
\n severity: warning
\n component: upstream
\n annotations:
\n summary: "High upstream response time"
\n description: |
\n 95%\u7684\u54cd\u5e94\u65f6\u95f4\u8d85\u8fc72\u79d2
\n \u5f53\u524d\u503c: {{ $value }}\u79d2<\/p>\n26.4.2 \u5206\u5e03\u5f0f\u8ffd\u8e2a\u96c6\u6210<\/h5>\n
python<\/p>\n
# OpenTelemetry\u8ffd\u8e2a\u96c6\u6210
\nfrom opentelemetry import trace
\nfrom opentelemetry.exporter.jaeger.thrift import JaegerExporter
\nfrom opentelemetry.sdk.trace import TracerProvider
\nfrom opentelemetry.sdk.trace.export import BatchSpanProcessor
\nfrom opentelemetry.instrumentation.requests import RequestsInstrumentor<\/p>\n# \u8bbe\u7f6e\u8ffd\u8e2a
\ntrace.set_tracer_provider(TracerProvider())
\ntracer = trace.get_tracer(__name__)<\/p>\n# Jaeger\u5bfc\u51fa\u5668
\njaeger_exporter = JaegerExporter(
\n agent_host_name="jaeger",
\n agent_port=6831,
\n)
\ntrace.get_tracer_provider().add_span_processor(
\n BatchSpanProcessor(jaeger_exporter)
\n)<\/p>\n# \u81ea\u52a8instrument\u8bf7\u6c42\u5e93
\nRequestsInstrumentor().instrument()<\/p>\nclass TracedGateway:
\n def __init__(self):
\n self.tracer = trace.get_tracer("gateway.service")<\/p>\nasync def handle_request(self, request):
\n # \u521b\u5efa\u5206\u5e03\u5f0f\u8ffd\u8e2aspan
\n with self.tracer.start_as_current_span("gateway.proxy") as span:
\n span.set_attribute("http.method", request.method)
\n span.set_attribute("http.url", request.url)
\n span.set_attribute("http.user_agent", request.headers.get('User-Agent'))<\/p>\ntry:
\n # \u6dfb\u52a0\u8ffd\u8e2a\u5934\u90e8
\n headers = dict(request.headers)
\n trace.instrumentation.utils._add_header(
\n headers,
\n span.get_span_context()
\n )<\/p>\n# \u8f6c\u53d1\u8bf7\u6c42
\n response = await self.proxy_request(request, headers)<\/p>\nspan.set_attribute("http.status_code", response.status)
\n span.set_status(trace.Status(trace.StatusCode.OK))<\/p>\nreturn response<\/p>\n
except Exception as e:
\n span.set_status(trace.Status(
\n trace.StatusCode.ERROR,
\n str(e)
\n ))
\n span.record_exception(e)<\/p>\n# \u8bb0\u5f55502\u9519\u8bef
\n span.set_attribute("error.type", "bad_gateway")
\n span.set_attribute("error.retryable", True)<\/p>\nraise<\/p>\n
26.5 \u9884\u9632\u4e0e\u4f18\u5316\u7b56\u7565<\/h4>\n
26.5.1 \u8fde\u63a5\u6c60\u4f18\u5316\u914d\u7f6e<\/h5>\n
java<\/p>\n
\/\/ Java\u8fde\u63a5\u6c60\u4f18\u5316\u793a\u4f8b
\n@Configuration
\npublic class ConnectionPoolConfig {<\/p>\n@Bean
\n public HttpClient httpClient() {
\n return HttpClient.create()
\n .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
\n .option(ChannelOption.SO_KEEPALIVE, true)<\/p>\n\/\/ \u8fde\u63a5\u6c60\u914d\u7f6e
\n .connectionProvider(
\n ConnectionProvider.builder("custom")
\n .maxConnections(500) \/\/ \u6700\u5927\u8fde\u63a5\u6570
\n .pendingAcquireTimeout(Duration.ofSeconds(60)) \/\/ \u83b7\u53d6\u8fde\u63a5\u8d85\u65f6
\n .pendingAcquireMaxCount(-1) \/\/ \u65e0\u9650\u5236\u7b49\u5f85\u961f\u5217
\n .maxIdleTime(Duration.ofSeconds(30)) \/\/ \u6700\u5927\u7a7a\u95f2\u65f6\u95f4
\n .maxLifeTime(Duration.ofMinutes(5)) \/\/ \u8fde\u63a5\u6700\u5927\u751f\u5b58\u65f6\u95f4
\n .evictInBackground(Duration.ofSeconds(120)) \/\/ \u540e\u53f0\u6e05\u7406\u95f4\u9694
\n .metrics(true) \/\/ \u542f\u7528\u6307\u6807
\n .build()
\n )<\/p>\n\/\/ \u54cd\u5e94\u8d85\u65f6
\n .responseTimeout(Duration.ofSeconds(30))<\/p>\n\/\/ \u91cd\u8bd5\u7b56\u7565
\n .doOnConnected(conn ->
\n conn.addHandlerLast(new ReadTimeoutHandler(30))
\n );
\n }<\/p>\n@Bean
\n public WebClient webClient(HttpClient httpClient) {
\n return WebClient.builder()
\n .clientConnector(new ReactorClientHttpConnector(httpClient))<\/p>\n\/\/ \u9ed8\u8ba4\u8fc7\u6ee4\u5668
\n .filter((request, next) -> {
\n long startTime = System.nanoTime();<\/p>\nreturn next.exchange(request)
\n .doOnSuccess(response -> {
\n long duration = System.nanoTime() – startTime;
\n logMetric(request, response, duration);
\n })
\n .doOnError(error -> {
\n long duration = System.nanoTime() – startTime;
\n logError(request, error, duration);
\n });
\n })
\n .build();
\n }
\n}<\/p>\n26.5.2 \u5bb9\u91cf\u89c4\u5212\u4e0e\u81ea\u52a8\u6269\u5c55<\/h5>\n
python<\/p>\n
# \u57fa\u4e8e\u9884\u6d4b\u7684\u81ea\u52a8\u6269\u5c55\u7b56\u7565
\nfrom sklearn.ensemble import RandomForestRegressor
\nimport numpy as np
\nfrom datetime import datetime, timedelta<\/p>\nclass PredictiveScaler:
\n def __init__(self):
\n self.model = RandomForestRegressor(n_estimators=100)
\n self.historical_data = []
\n self.retrain_interval = 3600 # \u6bcf\u5c0f\u65f6\u91cd\u8bad\u7ec3\u4e00\u6b21
\n self.last_retrain = 0<\/p>\ndef collect_metrics(self, timestamp, metrics):
\n """\u6536\u96c6\u6027\u80fd\u6307\u6807"""
\n data_point = {
\n 'timestamp': timestamp,
\n 'request_rate': metrics['requests_per_second'],
\n 'avg_response_time': metrics['avg_response_time_ms'],
\n 'error_rate': metrics['error_rate'],
\n 'active_connections': metrics['active_connections'],
\n 'cpu_usage': metrics['cpu_percent'],
\n 'memory_usage': metrics['memory_percent']
\n }
\n self.historical_data.append(data_point)<\/p>\n# \u4fdd\u6301\u6700\u8fd124\u5c0f\u65f6\u6570\u636e
\n cutoff = timestamp – timedelta(hours=24)
\n self.historical_data = [
\n d for d in self.historical_data
\n if d['timestamp'] > cutoff
\n ]<\/p>\ndef predict_load(self, lookahead_minutes=30):
\n """\u9884\u6d4b\u672a\u6765\u8d1f\u8f7d"""
\n current_time = datetime.now()<\/p>\n# \u51c6\u5907\u8bad\u7ec3\u6570\u636e
\n X = []
\n y = []<\/p>\nfor i in range(len(self.historical_data) – 1):
\n current = self.historical_data[i]
\n next_point = self.historical_data[i + 1]<\/p>\nfeatures = self.extract_features(current)
\n target = next_point['request_rate']<\/p>\nX.append(features)
\n y.append(target)<\/p>\nif len(X) < 100:
\n # \u6570\u636e\u4e0d\u8db3，\u4f7f\u7528\u7b80\u5355\u9884\u6d4b
\n return self.simple_prediction()<\/p>\n# \u5b9a\u671f\u91cd\u8bad\u7ec3\u6a21\u578b
\n if current_time.timestamp() – self.last_retrain > self.retrain_interval:
\n self.model.fit(X, y)
\n self.last_retrain = current_time.timestamp()<\/p>\n# \u9884\u6d4b
\n current_features = self.extract_features(self.historical_data[-1])
\n predicted_load = self.model.predict([current_features])[0]<\/p>\nreturn max(0, predicted_load)<\/p>\n
def calculate_desired_instances(self, current_instances):
\n """\u8ba1\u7b97\u6240\u9700\u5b9e\u4f8b\u6570"""
\n predicted_load = self.predict_load()
\n current_capacity = current_instances * 1000 # \u5047\u8bbe\u6bcf\u4e2a\u5b9e\u4f8b\u5904\u74061000 RPS<\/p>\nif predicted_load > current_capacity * 0.8: # 80%\u9608\u503c
\n # \u9700\u8981\u6269\u5bb9
\n desired_instances = int(np.ceil(predicted_load \/ 1000))
\n buffer = int(np.ceil(desired_instances * 0.2)) # 20%\u7f13\u51b2
\n return desired_instances + buffer<\/p>\nelif predicted_load < current_capacity * 0.3: # 30%\u9608\u503c
\n # \u53ef\u4ee5\u7f29\u5bb9
\n desired_instances = int(np.ceil(predicted_load \/ 1000))
\n return max(1, desired_instances) # \u81f3\u5c11\u4fdd\u75591\u4e2a\u5b9e\u4f8b<\/p>\nreturn current_instances<\/p>\n
def extract_features(self, data_point):
\n """\u4ece\u6570\u636e\u70b9\u63d0\u53d6\u7279\u5f81"""
\n hour = data_point['timestamp'].hour
\n day_of_week = data_point['timestamp'].weekday()<\/p>\nreturn [
\n hour,
\n day_of_week,
\n data_point['request_rate'],
\n data_point['avg_response_time'],
\n data_point['error_rate'],
\n data_point['active_connections'],
\n data_point['cpu_usage'],
\n data_point['memory_usage']
\n ]<\/p>\n26.6 \u6700\u4f73\u5b9e\u8df5\u603b\u7ed3<\/h4>\n
26.6.1 \u914d\u7f6e\u68c0\u67e5\u6e05\u5355<\/h5>\n
Nginx\u914d\u7f6e\u4f18\u5316：<\/p>\n
text<\/p>\n
\u2705 proxy_connect_timeout: 5-10\u79d2
\n\u2705 proxy_read_timeout: \u6839\u636e\u4e1a\u52a1\u8c03\u6574（\u901a\u5e3830-60\u79d2）
\n\u2705 proxy_send_timeout: 30-60\u79d2
\n\u2705 proxy_buffer_size: 4k\u62168k
\n\u2705 proxy_buffers: 8 4k\u62168k
\n\u2705 proxy_next_upstream: error timeout invalid_header http_502
\n\u2705 proxy_next_upstream_tries: 2-3\u6b21
\n\u2705 keepalive_connections: 32-64<\/p>\n\u5e94\u7528\u670d\u52a1\u5668\u914d\u7f6e：<\/p>\n
text<\/p>\n
\u2705 \u8fde\u63a5\u6c60\u5927\u5c0f：\u6839\u636e\u8d1f\u8f7d\u8c03\u6574
\n\u2705 \u7ebf\u7a0b\u6c60\u914d\u7f6e：\u907f\u514d\u8d44\u6e90\u8017\u5c3d
\n\u2705 \u5185\u5b58\u9650\u5236：\u9632\u6b62OOM
\n\u2705 \u5065\u5eb7\u68c0\u67e5\u7aef\u70b9：\/health, \/ready, \/live
\n\u2705 \u4f18\u96c5\u5173\u95ed：\u5904\u7406SIGTERM\u4fe1\u53f7<\/p>\n26.6.2 \u76d1\u63a7\u6307\u6807\u5173\u952e\u70b9<\/h5>\n
- \n
\u7f51\u5173\u5c42\u6307\u6807：<\/p>\n
- \n
- \n
502\u9519\u8bef\u7387（\u76ee\u6807：< 0.1%）<\/p>\n<\/li>\n
- \n
\u5e73\u5747\u54cd\u5e94\u65f6\u95f4（\u76ee\u6807：< 200ms）<\/p>\n<\/li>\n
- \n
\u8fde\u63a5\u6c60\u4f7f\u7528\u7387（\u76ee\u6807：< 80%）<\/p>\n<\/li>\n<\/ul>\n<\/li>\n
- \n
\u4e0a\u6e38\u670d\u52a1\u6307\u6807：<\/p>\n
- \n
- \n
\u670d\u52a1\u53ef\u7528\u6027（\u76ee\u6807：> 99.9%）<\/p>\n<\/li>\n
- \n
\u9519\u8bef\u7387（\u76ee\u6807：< 0.5%）<\/p>\n<\/li>\n
- \n
\u8d44\u6e90\u4f7f\u7528\u7387（CPU\u3001\u5185\u5b58\u3001\u8fde\u63a5）<\/p>\n<\/li>\n<\/ul>\n<\/li>\n
- \n
\u7f51\u7edc\u6307\u6807：<\/p>\n
- \n
- \n
\u5ef6\u8fdf（\u76ee\u6807：< 50ms）<\/p>\n<\/li>\n
- \n
\u4e22\u5305\u7387（\u76ee\u6807：< 0.1%）<\/p>\n<\/li>\n
- \n
\u5e26\u5bbd\u4f7f\u7528\u7387（\u76ee\u6807：< 70%）<\/p>\n<\/li>\n<\/ul>\n<\/li>\n
\u901a\u8fc7\u5b9e\u65bd\u8fd9\u4e9b\u7b56\u7565，\u53ef\u4ee5\u663e\u8457\u964d\u4f4e502\u9519\u8bef\u7684\u53d1\u751f\u7387，\u63d0\u9ad8\u7cfb\u7edf\u7684\u6574\u4f53\u53ef\u9760\u6027\u3002<\/p>\n
\n\u7b2c27\u7ae0：503 Service Unavailable – \u670d\u52a1\u4e0d\u53ef\u7528<\/h3>\n
27.1 \u6df1\u5165\u89e3\u6790\u670d\u52a1\u4e0d\u53ef\u7528\u72b6\u6001<\/h4>\n
503 Service Unavailable\u00a0\u8868\u793a\u670d\u52a1\u5668\u6682\u65f6\u65e0\u6cd5\u5904\u7406\u8bf7\u6c42，\u901a\u5e38\u662f\u7531\u4e8e\u8fc7\u8f7d\u6216\u7ef4\u62a4\u3002\u4e0e502\u4e0d\u540c，503\u8868\u793a\u670d\u52a1\u5668\u672c\u8eab\u77e5\u9053\u5b83\u6682\u65f6\u65e0\u6cd5\u63d0\u4f9b\u670d\u52a1\u3002<\/p>\n
27.1.1 \u534f\u8bae\u89c4\u8303\u4e0e\u8bed\u4e49<\/h5>\n
- \n
- \n
RFC 7231\u5b9a\u4e49：\u670d\u52a1\u5668\u5f53\u524d\u65e0\u6cd5\u5904\u7406\u8bf7\u6c42，\u56e0\u4e3a\u4e34\u65f6\u7684\u8fc7\u8f7d\u6216\u7cfb\u7edf\u7ef4\u62a4<\/p>\n<\/li>\n
- \n
\u5173\u952e\u7279\u6027：<\/p>\n
- \n
- \n
\u4e34\u65f6\u6027\u9519\u8bef（\u5bf9\u6bd4501\u7684\u6c38\u4e45\u6027）<\/p>\n<\/li>\n
- \n
\u901a\u5e38\u5e94\u5305\u542bRetry-After\u5934\u90e8<\/p>\n<\/li>\n
- \n
\u53ef\u80fd\u7531\u4e8e\u8ba1\u5212\u7ef4\u62a4\u3001\u8fc7\u8f7d\u6216\u4f9d\u8d56\u670d\u52a1\u6545\u969c<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
27.1.2 \u4e0e\u76f8\u5173\u72b6\u6001\u7801\u7684\u7cbe\u786e\u533a\u5206
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/07\/20260726181700-6a664f1c2aef5.png\")
<\/h5>\n27.2 \u5bb9\u91cf\u7ba1\u7406\u4e0e\u8fc7\u8f7d\u4fdd\u62a4<\/h4>\n
27.2.1 \u57fa\u4e8e\u961f\u5217\u7406\u8bba\u7684\u5bb9\u91cf\u6a21\u578b<\/h5>\n
python<\/p>\n
# \u670d\u52a1\u5bb9\u91cf\u7ba1\u7406\u4e0e\u8fc7\u8f7d\u4fdd\u62a4\u7cfb\u7edf
\nimport asyncio
\nimport time
\nfrom collections import deque
\nfrom dataclasses import dataclass
\nfrom typing import Optional, Deque
\nimport statistics<\/p>\n@dataclass
\nclass Request:
\n id: str
\n arrival_time: float
\n priority: int = 1
\n timeout: float = 30.0<\/p>\n@dataclass
\nclass CapacityMetrics:
\n """\u5bb9\u91cf\u6307\u6807"""
\n arrival_rate: float = 0.0 # \u8bf7\u6c42\u5230\u8fbe\u7387 (requests\/second)
\n service_rate: float = 0.0 # \u670d\u52a1\u7387 (requests\/second)
\n queue_length: int = 0 # \u961f\u5217\u957f\u5ea6
\n utilization: float = 0.0 # \u5229\u7528\u7387 (arrival_rate \/ service_rate)
\n response_time_95: float = 0.0 # 95%\u54cd\u5e94\u65f6\u95f4
\n error_rate: float = 0.0 # \u9519\u8bef\u7387<\/p>\nclass AdaptiveRateLimiter:
\n """\u81ea\u9002\u5e94\u901f\u7387\u9650\u5236\u5668"""<\/p>\ndef __init__(self, initial_capacity: int = 100):
\n self.max_capacity = initial_capacity
\n self.current_capacity = initial_capacity
\n self.queue: Deque[Request] = deque()
\n self.in_progress = 0
\n self.metrics_history = deque(maxlen=1000)<\/p>\n# \u63a7\u5236\u53c2\u6570
\n self.target_response_time = 0.2 # \u76ee\u6807\u54cd\u5e94\u65f6\u95f4200ms
\n self.target_utilization = 0.7 # \u76ee\u6807\u5229\u7528\u738770%
\n self.min_capacity = 10 # \u6700\u5c0f\u5bb9\u91cf
\n self.adjustment_cooldown = 5.0 # \u8c03\u6574\u51b7\u5374\u65f6\u95f4<\/p>\nself.last_adjustment = 0.0
\n self.last_rejection = 0.0<\/p>\ndef should_accept(self, request: Request) -> bool:
\n """\u51b3\u5b9a\u662f\u5426\u63a5\u53d7\u65b0\u8bf7\u6c42"""
\n current_time = time.time()<\/p>\n# \u8ba1\u7b97\u5f53\u524d\u6307\u6807
\n metrics = self._calculate_metrics(current_time)<\/p>\n# \u68c0\u67e5\u662f\u5426\u8fc7\u8f7d
\n if self._is_overloaded(metrics, current_time):
\n return False<\/p>\n# \u57fa\u4e8e\u961f\u5217\u957f\u5ea6\u9650\u5236
\n if len(self.queue) >= self.current_capacity * 2:
\n return False<\/p>\n# \u57fa\u4e8e\u54cd\u5e94\u65f6\u95f4\u9884\u6d4b
\n predicted_response_time = self._predict_response_time(metrics)
\n if predicted_response_time > request.timeout * 0.8:
\n return False<\/p>\nreturn True<\/p>\n
def _is_overloaded(self, metrics: CapacityMetrics, current_time: float) -> bool:
\n """\u5224\u65ad\u7cfb\u7edf\u662f\u5426\u8fc7\u8f7d"""<\/p>\n# \u6807\u51c61：\u54cd\u5e94\u65f6\u95f4\u8d85\u8fc7\u9608\u503c
\n if metrics.response_time_95 > self.target_response_time * 3:
\n return True<\/p>\n# \u6807\u51c62：\u9519\u8bef\u7387\u8fc7\u9ad8
\n if metrics.error_rate > 0.1: # 10%\u9519\u8bef\u7387
\n return True<\/p>\n# \u6807\u51c63：\u961f\u5217\u8fc7\u957f
\n if metrics.queue_length > self.current_capacity * 3:
\n return True<\/p>\n# \u6807\u51c64：\u8fd1\u671f\u6709\u592a\u591a\u62d2\u7edd
\n if (current_time – self.last_rejection < 1.0 and
\n metrics.arrival_rate > self.current_capacity * 2):
\n return True<\/p>\nreturn False<\/p>\n
def _calculate_metrics(self, current_time: float) -> CapacityMetrics:
\n """\u8ba1\u7b97\u5f53\u524d\u6027\u80fd\u6307\u6807"""
\n metrics = CapacityMetrics()<\/p>\n# \u8ba1\u7b97\u5230\u8fbe\u7387（\u57fa\u4e8e\u6700\u8fd110\u79d2）
\n recent_arrivals = [
\n r for r in self.metrics_history
\n if current_time – r['timestamp'] < 10
\n ]<\/p>\nif recent_arrivals:
\n arrival_times = [r['timestamp'] for r in recent_arrivals]
\n metrics.arrival_rate = len(recent_arrivals) \/ 10.0<\/p>\n# \u8ba1\u7b97\u670d\u52a1\u7387
\n completed = [r for r in recent_arrivals if r['completed']]
\n if completed:
\n service_times = [r['service_time'] for r in completed]
\n metrics.service_rate = 1.0 \/ statistics.mean(service_times)<\/p>\n# \u961f\u5217\u957f\u5ea6
\n metrics.queue_length = len(self.queue)<\/p>\n# \u5229\u7528\u7387
\n if metrics.service_rate > 0:
\n metrics.utilization = metrics.arrival_rate \/ metrics.service_rate<\/p>\n# \u54cd\u5e94\u65f6\u95f4\u767e\u5206\u4f4d
\n response_times = [r['response_time'] for r in recent_arrivals
\n if 'response_time' in r]
\n if response_times:
\n metrics.response_time_95 = statistics.quantiles(
\n response_times, n=20
\n )[18] if len(response_times) >= 5 else response_times[-1]<\/p>\n# \u9519\u8bef\u7387
\n errors = [r for r in recent_arrivals if r.get('error', False)]
\n if recent_arrivals:
\n metrics.error_rate = len(errors) \/ len(recent_arrivals)<\/p>\nreturn metrics<\/p>\n
def _predict_response_time(self, metrics: CapacityMetrics) -> float:
\n """\u9884\u6d4b\u54cd\u5e94\u65f6\u95f4（\u57fa\u4e8eM\/M\/1\u961f\u5217\u6a21\u578b）"""
\n if metrics.utilization >= 1.0:
\n # \u7cfb\u7edf\u9971\u548c，\u54cd\u5e94\u65f6\u95f4\u8d8b\u4e8e\u65e0\u9650
\n return float('inf')<\/p>\nif metrics.service_rate == 0:
\n return 0.0<\/p>\n# M\/M\/1\u961f\u5217\u516c\u5f0f：\u54cd\u5e94\u65f6\u95f4 = 1\/\u03bc \/ (1 – \u03c1)
\n # \u5176\u4e2d\u03bc\u662f\u670d\u52a1\u7387，\u03c1\u662f\u5229\u7528\u7387
\n if metrics.utilization < 0.95:
\n expected_service_time = 1.0 \/ metrics.service_rate
\n predicted = expected_service_time \/ (1 – metrics.utilization)
\n return predicted
\n else:
\n return float('inf')<\/p>\nasync def adjust_capacity(self, current_time: float):
\n """\u81ea\u9002\u5e94\u8c03\u6574\u5bb9\u91cf"""
\n if current_time – self.last_adjustment < self.adjustment_cooldown:
\n return<\/p>\nmetrics = self._calculate_metrics(current_time)<\/p>\n
# \u57fa\u4e8e\u54cd\u5e94\u65f6\u95f4\u8c03\u6574
\n if metrics.response_time_95 > self.target_response_time * 1.5:
\n # \u54cd\u5e94\u65f6\u95f4\u8fc7\u9ad8，\u964d\u4f4e\u5bb9\u91cf
\n reduction = self._calculate_reduction(metrics)
\n self.current_capacity = max(
\n self.min_capacity,
\n int(self.current_capacity * reduction)
\n )<\/p>\nelif (metrics.utilization < self.target_utilization * 0.8 and
\n metrics.response_time_95 < self.target_response_time * 0.8):
\n # \u5229\u7528\u7387\u4f4e\u4e14\u54cd\u5e94\u65f6\u95f4\u597d，\u53ef\u4ee5\u589e\u52a0\u5bb9\u91cf
\n increase = self._calculate_increase(metrics)
\n self.current_capacity = min(
\n self.max_capacity,
\n int(self.current_capacity * increase)
\n )<\/p>\nself.last_adjustment = current_time<\/p>\n
def _calculate_reduction(self, metrics: CapacityMetrics) -> float:
\n """\u8ba1\u7b97\u5bb9\u91cf\u51cf\u5c11\u6bd4\u4f8b"""
\n # \u54cd\u5e94\u65f6\u95f4\u8d85\u8fc7\u76ee\u6807\u7684\u500d\u6570
\n overshoot_ratio = metrics.response_time_95 \/ self.target_response_time<\/p>\nif overshoot_ratio > 3.0:
\n # \u4e25\u91cd\u8fc7\u8f7d，\u5927\u5e45\u51cf\u5c11
\n return 0.5
\n elif overshoot_ratio > 2.0:
\n # \u4e2d\u5ea6\u8fc7\u8f7d
\n return 0.7
\n else:
\n # \u8f7b\u5fae\u8fc7\u8f7d
\n return 0.9<\/p>\ndef create_503_response(self, request: Request,
\n metrics: CapacityMetrics) -> dict:
\n """\u521b\u5efa\u667a\u80fd\u7684503\u54cd\u5e94"""
\n current_time = time.time()<\/p>\n# \u8ba1\u7b97\u5efa\u8bae\u7684\u91cd\u8bd5\u65f6\u95f4
\n if self.queue:
\n avg_service_time = 1.0 \/ metrics.service_rate if metrics.service_rate > 0 else 1.0
\n queue_wait = len(self.queue) * avg_service_time
\n retry_after = min(30, max(1, int(queue_wait)))
\n else:
\n retry_after = 5 # \u9ed8\u8ba45\u79d2<\/p>\nresponse = {
\n "status": 503,
\n "headers": {
\n "Content-Type": "application\/json",
\n "Retry-After": str(retry_after)
\n },
\n "body": {
\n "error": {
\n "code": "service_unavailable",
\n "message": "Service is temporarily overloaded",
\n "details": {
\n "request_id": request.id,
\n "timestamp": current_time,
\n "queue_position": len(self.queue) if request in self.queue else None,
\n "estimated_wait_time": retry_after,
\n "current_metrics": {
\n "arrival_rate": round(metrics.arrival_rate, 2),
\n "utilization": round(metrics.utilization, 3),
\n "queue_length": metrics.queue_length,
\n "response_time_95": round(metrics.response_time_95, 3)
\n },
\n "suggestions": [
\n f"Please retry after {retry_after} seconds",
\n "Use exponential backoff for retries",
\n "Check service status at status.example.com"
\n ]
\n }
\n }
\n }
\n }<\/p>\n# \u8bb0\u5f55\u62d2\u7edd
\n self.last_rejection = current_time
\n self.metrics_history.append({
\n "timestamp": current_time,
\n "request_id": request.id,
\n "rejected": True,
\n "queue_length": metrics.queue_length,
\n "arrival_rate": metrics.arrival_rate
\n })<\/p>\nreturn response<\/p>\n
27.2.2 \u5206\u5e03\u5f0f\u9650\u6d41\u4e0e\u914d\u989d\u7ba1\u7406<\/h5>\n
java<\/p>\n
\/\/ \u57fa\u4e8eRedis\u7684\u5206\u5e03\u5f0f\u9650\u6d41\u5668
\n@Slf4j
\n@Component
\npublic class DistributedRateLimiter {<\/p>\nprivate final RedisTemplate<String, String> redisTemplate;
\n private final ObjectMapper objectMapper;<\/p>\n\/\/ \u9650\u6d41\u914d\u7f6e
\n private final Map<String, RateLimitConfig> rateLimitConfigs;<\/p>\n@Data
\n @AllArgsConstructor
\n static class RateLimitConfig {
\n private int requestsPerSecond;
\n private int burstCapacity;
\n private Duration windowSize;
\n private boolean enabled;
\n }<\/p>\npublic DistributedRateLimiter(RedisTemplate<String, String> redisTemplate,
\n ObjectMapper objectMapper) {
\n this.redisTemplate = redisTemplate;
\n this.objectMapper = objectMapper;
\n this.rateLimitConfigs = loadRateLimitConfigs();
\n }<\/p>\n\/**
\n * \u68c0\u67e5\u8bf7\u6c42\u662f\u5426\u5e94\u8be5\u88ab\u9650\u6d41
\n *\/
\n public RateLimitResult checkRateLimit(String clientId, String endpoint) {
\n String key = String.format("rate_limit:%s:%s", clientId, endpoint);
\n RateLimitConfig config = rateLimitConfigs.getOrDefault(endpoint,
\n new RateLimitConfig(100, 200, Duration.ofSeconds(1), true));<\/p>\nif (!config.isEnabled()) {
\n return RateLimitResult.allowed();
\n }<\/p>\nlong currentTime = System.currentTimeMillis();
\n long windowStart = currentTime – config.getWindowSize().toMillis();<\/p>\n\/\/ \u4f7f\u7528Redis sorted set\u5b9e\u73b0\u6ed1\u52a8\u7a97\u53e3
\n String windowKey = key + ":window";<\/p>\n\/\/ \u79fb\u9664\u7a97\u53e3\u5916\u7684\u8bf7\u6c42
\n redisTemplate.opsForZSet().removeRangeByScore(
\n windowKey, 0, windowStart – 1
\n );<\/p>\n\/\/ \u83b7\u53d6\u5f53\u524d\u7a97\u53e3\u5185\u7684\u8bf7\u6c42\u6570
\n Long requestCount = redisTemplate.opsForZSet().zCard(windowKey);<\/p>\nif (requestCount == null) {
\n requestCount = 0L;
\n }<\/p>\n\/\/ \u68c0\u67e5\u662f\u5426\u8d85\u8fc7\u9650\u5236
\n if (requestCount >= config.getRequestsPerSecond()) {
\n \/\/ \u8ba1\u7b97\u4e0b\u4e00\u4e2a\u53ef\u7528\u65f6\u95f4
\n Double oldestScore = redisTemplate.opsForZSet()
\n .rangeWithScores(windowKey, 0, 0)
\n .stream()
\n .findFirst()
\n .map(TypedTuple::getScore)
\n .orElse((double) currentTime);<\/p>\nlong retryAfter = (long) (oldestScore + 1000) – currentTime;
\n retryAfter = Math.max(1, retryAfter \/ 1000);<\/p>\nreturn RateLimitResult.rateLimited(retryAfter);
\n }<\/p>\n\/\/ \u6dfb\u52a0\u5f53\u524d\u8bf7\u6c42\u5230\u7a97\u53e3
\n redisTemplate.opsForZSet().add(
\n windowKey,
\n UUID.randomUUID().toString(),
\n currentTime
\n );<\/p>\n\/\/ \u8bbe\u7f6ekey\u7684\u8fc7\u671f\u65f6\u95f4
\n redisTemplate.expire(windowKey, config.getWindowSize().plusSeconds(10));<\/p>\n\/\/ \u8ba1\u7b97\u5269\u4f59\u914d\u989d
\n long remaining = config.getRequestsPerSecond() – requestCount – 1;<\/p>\nreturn RateLimitResult.allowed(remaining);
\n }<\/p>\n\/**
\n * \u81ea\u9002\u5e94\u8c03\u6574\u9650\u6d41\u914d\u7f6e
\n *\/
\n public void adjustRateLimits(SystemMetrics metrics) {
\n for (Map.Entry<String, RateLimitConfig> entry : rateLimitConfigs.entrySet()) {
\n String endpoint = entry.getKey();
\n RateLimitConfig config = entry.getValue();<\/p>\n\/\/ \u57fa\u4e8e\u7cfb\u7edf\u6307\u6807\u52a8\u6001\u8c03\u6574
\n if (metrics.getErrorRate() > 0.1) {
\n \/\/ \u9519\u8bef\u7387\u9ad8，\u964d\u4f4e\u9650\u6d41\u9608\u503c
\n int newLimit = (int) (config.getRequestsPerSecond() * 0.8);
\n config.setRequestsPerSecond(Math.max(10, newLimit));
\n log.info("Reduced rate limit for {} to {}", endpoint, newLimit);<\/p>\n} else if (metrics.getCpuUsage() > 0.8) {
\n \/\/ CPU\u4f7f\u7528\u7387\u9ad8，\u964d\u4f4e\u9650\u6d41\u9608\u503c
\n int newLimit = (int) (config.getRequestsPerSecond() * 0.9);
\n config.setRequestsPerSecond(Math.max(10, newLimit));
\n log.info("Reduced rate limit for {} due to high CPU", endpoint);<\/p>\n} else if (metrics.getErrorRate() < 0.01 &&
\n metrics.getCpuUsage() < 0.6 &&
\n metrics.getResponseTime95() < 200) {
\n \/\/ \u7cfb\u7edf\u5065\u5eb7，\u53ef\u4ee5\u9002\u5f53\u63d0\u9ad8\u9650\u6d41\u9608\u503c
\n int newLimit = (int) (config.getRequestsPerSecond() * 1.1);
\n config.setRequestsPerSecond(Math.min(1000, newLimit));
\n log.info("Increased rate limit for {} to {}", endpoint, newLimit);
\n }
\n }
\n }<\/p>\n@Data
\n @AllArgsConstructor
\n static class RateLimitResult {
\n private boolean allowed;
\n private long remainingRequests;
\n private long retryAfterSeconds;
\n private String message;<\/p>\npublic static RateLimitResult allowed() {
\n return new RateLimitResult(true, -1, 0, null);
\n }<\/p>\npublic static RateLimitResult allowed(long remaining) {
\n return new RateLimitResult(true, remaining, 0, null);
\n }<\/p>\npublic static RateLimitResult rateLimited(long retryAfter) {
\n return new RateLimitResult(false, 0, retryAfter,
\n "Rate limit exceeded. Please retry after " + retryAfter + " seconds.");
\n }
\n }
\n}<\/p>\n27.3 \u4f18\u96c5\u7684\u670d\u52a1\u964d\u7ea7<\/h4>\n
27.3.1 \u591a\u7ea7\u964d\u7ea7\u7b56\u7565\u5b9e\u73b0<\/h5>\n
python<\/p>\n
# \u670d\u52a1\u964d\u7ea7\u7ba1\u7406\u5668
\nfrom enum import Enum
\nfrom typing import Dict, Any, Optional, Callable
\nimport time
\nfrom dataclasses import dataclass
\nfrom functools import wraps<\/p>\nclass DegradationLevel(Enum):
\n """\u964d\u7ea7\u7ea7\u522b"""
\n NORMAL = "normal" # \u6b63\u5e38\u6a21\u5f0f
\n DEGRADED = "degraded" # \u964d\u7ea7\u6a21\u5f0f
\n MINIMAL = "minimal" # \u6700\u5c0f\u529f\u80fd\u6a21\u5f0f
\n EMERGENCY = "emergency" # \u7d27\u6025\u6a21\u5f0f<\/p>\n@dataclass
\nclass DegradationRule:
\n """\u964d\u7ea7\u89c4\u5219"""
\n metric_name: str # \u6307\u6807\u540d\u79f0
\n threshold: float # \u9608\u503c
\n duration: float # \u6301\u7eed\u65f6\u95f4（\u79d2）
\n target_level: DegradationLevel # \u76ee\u6807\u964d\u7ea7\u7ea7\u522b
\n cooldown: float = 300 # \u51b7\u5374\u65f6\u95f4（\u79d2）<\/p>\nclass ServiceDegrader:
\n """\u670d\u52a1\u964d\u7ea7\u7ba1\u7406\u5668"""<\/p>\ndef __init__(self):
\n self.current_level = DegradationLevel.NORMAL
\n self.rules: Dict[str, DegradationRule] = {}
\n self.metrics_history = {}
\n self.last_level_change = time.time()<\/p>\n# \u9ed8\u8ba4\u964d\u7ea7\u89c4\u5219
\n self._setup_default_rules()<\/p>\n# \u964d\u7ea7\u5904\u7406\u5668\u6620\u5c04
\n self.degradation_handlers = {
\n DegradationLevel.NORMAL: self._handle_normal,
\n DegradationLevel.DEGRADED: self._handle_degraded,
\n DegradationLevel.MINIMAL: self._handle_minimal,
\n DegradationLevel.EMERGENCY: self._handle_emergency
\n }<\/p>\ndef _setup_default_rules(self):
\n """\u8bbe\u7f6e\u9ed8\u8ba4\u964d\u7ea7\u89c4\u5219"""
\n self.rules = {
\n # CPU\u4f7f\u7528\u7387\u89c4\u5219
\n "high_cpu": DegradationRule(
\n metric_name="cpu_usage",
\n threshold=0.8, # 80%
\n duration=30, # \u6301\u7eed30\u79d2
\n target_level=DegradationLevel.DEGRADED
\n ),<\/p>\n# \u5185\u5b58\u4f7f\u7528\u7387\u89c4\u5219
\n "high_memory": DegradationRule(
\n metric_name="memory_usage",
\n threshold=0.9, # 90%
\n duration=10,
\n target_level=DegradationLevel.MINIMAL
\n ),<\/p>\n# \u9519\u8bef\u7387\u89c4\u5219
\n "high_error_rate": DegradationRule(
\n metric_name="error_rate",
\n threshold=0.1, # 10%
\n duration=60,
\n target_level=DegradationLevel.DEGRADED
\n ),<\/p>\n# \u54cd\u5e94\u65f6\u95f4\u89c4\u5219
\n "slow_response": DegradationRule(
\n metric_name="response_time_95",
\n threshold=2.0, # 2\u79d2
\n duration=30,
\n target_level=DegradationLevel.DEGRADED
\n ),<\/p>\n# \u961f\u5217\u957f\u5ea6\u89c4\u5219
\n "long_queue": DegradationRule(
\n metric_name="queue_length",
\n threshold=1000,
\n duration=10,
\n target_level=DegradationLevel.MINIMAL
\n )
\n }<\/p>\ndef update_metrics(self, metrics: Dict[str, float]):
\n """\u66f4\u65b0\u6307\u6807\u5e76\u68c0\u67e5\u662f\u5426\u9700\u8981\u964d\u7ea7"""
\n current_time = time.time()<\/p>\n# \u66f4\u65b0\u6307\u6807\u5386\u53f2
\n for name, value in metrics.items():
\n if name not in self.metrics_history:
\n self.metrics_history[name] = []<\/p>\nself.metrics_history[name].append({
\n "timestamp": current_time,
\n "value": value
\n })<\/p>\n# \u4fdd\u7559\u6700\u8fd15\u5206\u949f\u6570\u636e
\n cutoff = current_time – 300
\n self.metrics_history[name] = [
\n m for m in self.metrics_history[name]
\n if m["timestamp"] > cutoff
\n ]<\/p>\n# \u68c0\u67e5\u964d\u7ea7\u89c4\u5219
\n new_level = self._evaluate_rules(current_time)<\/p>\n# \u5982\u679c\u68c0\u6d4b\u5230\u9700\u8981\u964d\u7ea7
\n if new_level != self.current_level:
\n # \u68c0\u67e5\u51b7\u5374\u65f6\u95f4
\n if current_time – self.last_level_change < 60:
\n # \u907f\u514d\u9891\u7e41\u5207\u6362
\n return<\/p>\nold_level = self.current_level
\n self.current_level = new_level
\n self.last_level_change = current_time<\/p>\n# \u8bb0\u5f55\u72b6\u6001\u53d8\u5316
\n self._log_degradation_change(old_level, new_level, metrics)<\/p>\n# \u6267\u884c\u964d\u7ea7\/\u6062\u590d\u64cd\u4f5c
\n self._execute_degradation_actions(old_level, new_level)<\/p>\ndef _evaluate_rules(self, current_time: float) -> DegradationLevel:
\n """\u8bc4\u4f30\u6240\u6709\u964d\u7ea7\u89c4\u5219"""
\n target_level = self.current_level<\/p>\nfor rule_name, rule in self.rules.items():
\n metric_history = self.metrics_history.get(rule.metric_name, [])<\/p>\nif not metric_history:
\n continue<\/p>\n# \u68c0\u67e5\u6700\u8fd1duration\u79d2\u5185\u7684\u6307\u6807
\n recent_metrics = [
\n m for m in metric_history
\n if current_time – m["timestamp"] <= rule.duration
\n ]<\/p>\nif not recent_metrics:
\n continue<\/p>\n# \u68c0\u67e5\u662f\u5426\u8d85\u8fc7\u9608\u503c
\n values = [m["value"] for m in recent_metrics]
\n avg_value = sum(values) \/ len(values)<\/p>\nif avg_value >= rule.threshold:
\n # \u9700\u8981\u964d\u7ea7
\n if rule.target_level.value > target_level.value:
\n target_level = rule.target_level<\/p>\nreturn target_level<\/p>\n
def _handle_normal(self, request, **kwargs):
\n """\u6b63\u5e38\u6a21\u5f0f\u5904\u7406"""
\n return self._process_full_features(request, **kwargs)<\/p>\ndef _handle_degraded(self, request, **kwargs):
\n """\u964d\u7ea7\u6a21\u5f0f\u5904\u7406"""
\n # \u5173\u95ed\u975e\u6838\u5fc3\u529f\u80fd
\n features = kwargs.get('features', {})<\/p>\n# \u7981\u7528\u9ad8\u6210\u672c\u529f\u80fd
\n if features.get('enable_ai_analysis', False):
\n features['enable_ai_analysis'] = False<\/p>\nif features.get('enable_realtime_processing', False):
\n features['enable_realtime_processing'] = False<\/p>\n# \u4f7f\u7528\u7f13\u5b58\u800c\u4e0d\u662f\u5b9e\u65f6\u8ba1\u7b97
\n use_cache = True<\/p>\nreturn self._process_basic_features(request,
\n use_cache=use_cache,
\n **kwargs)<\/p>\ndef _handle_minimal(self, request, **kwargs):
\n """\u6700\u5c0f\u529f\u80fd\u6a21\u5f0f"""
\n # \u53ea\u63d0\u4f9b\u6838\u5fc3\u529f\u80fd
\n features = {
\n 'enable_cache': True,
\n 'enable_basic_processing': True,
\n 'enable_advanced_features': False,
\n 'enable_external_calls': False
\n }<\/p>\n# \u8bbe\u7f6e\u8d85\u65f6\u65f6\u95f4
\n kwargs['timeout'] = min(kwargs.get('timeout', 30), 5)<\/p>\nreturn self._process_minimal_features(request, **kwargs)<\/p>\n
def _handle_emergency(self, request, **kwargs):
\n """\u7d27\u6025\u6a21\u5f0f"""
\n # \u8fd4\u56de\u9759\u6001\u54cd\u5e94\u6216\u9519\u8bef\u9875\u9762
\n return {
\n "status": 503,
\n "headers": {
\n "Content-Type": "application\/json",
\n "Retry-After": "60"
\n },
\n "body": {
\n "error": {
\n "code": "service_emergency",
\n "message": "Service is in emergency mode",
\n "details": {
\n "mode": "emergency",
\n "minimal_features_only": True,
\n "estimated_recovery_time": "unknown",
\n "status_page": "https:\/\/status.example.com"
\n }
\n }
\n }
\n }<\/p>\ndef process_request(self, request, **kwargs):
\n """\u6839\u636e\u5f53\u524d\u964d\u7ea7\u7ea7\u522b\u5904\u7406\u8bf7\u6c42"""
\n handler = self.degradation_handlers[self.current_level]
\n return handler(request, **kwargs)<\/p>\ndef degrade_method(self, feature_name: str):
\n """\u65b9\u6cd5\u88c5\u9970\u5668：\u6839\u636e\u964d\u7ea7\u7ea7\u522b\u8c03\u6574\u884c\u4e3a"""
\n def decorator(func):
\n @wraps(func)
\n def wrapper(*args, **kwargs):
\n # \u68c0\u67e5\u529f\u80fd\u5728\u5f53\u524d\u964d\u7ea7\u7ea7\u522b\u662f\u5426\u53ef\u7528
\n if not self._is_feature_available(feature_name):
\n # \u8fd4\u56de\u964d\u7ea7\u54cd\u5e94
\n return self._get_degraded_response(feature_name)<\/p>\n# \u6839\u636e\u964d\u7ea7\u7ea7\u522b\u8c03\u6574\u53c2\u6570
\n if self.current_level == DegradationLevel.DEGRADED:
\n # \u964d\u7ea7\u6a21\u5f0f：\u589e\u52a0\u8d85\u65f6，\u7981\u7528\u67d0\u4e9b\u9009\u9879
\n kwargs['timeout'] = min(kwargs.get('timeout', 30), 10)
\n kwargs['enable_optimizations'] = False<\/p>\nelif self.current_level == DegradationLevel.MINIMAL:
\n # \u6700\u5c0f\u6a21\u5f0f：\u4f7f\u7528\u7b80\u5316\u7248\u672c
\n if hasattr(func, 'minimal_version'):
\n return func.minimal_version(*args, **kwargs)<\/p>\nreturn func(*args, **kwargs)<\/p>\n
return wrapper
\n return decorator<\/p>\ndef _is_feature_available(self, feature_name: str) -> bool:
\n """\u68c0\u67e5\u529f\u80fd\u5728\u5f53\u524d\u964d\u7ea7\u7ea7\u522b\u662f\u5426\u53ef\u7528"""
\n feature_availability = {
\n DegradationLevel.NORMAL: ['all'],
\n DegradationLevel.DEGRADED: ['core', 'basic', 'cache'],
\n DegradationLevel.MINIMAL: ['core', 'cache'],
\n DegradationLevel.EMERGENCY: ['core']
\n }<\/p>\navailable_features = feature_availability.get(
\n self.current_level, ['core']
\n )<\/p>\nreturn 'all' in available_features or feature_name in available_features<\/p>\n
27.4 \u667a\u80fd\u91cd\u8bd5\u4e0e\u5ba2\u6237\u7aef\u5904\u7406<\/h4>\n
27.4.1 \u5ba2\u6237\u7aef\u91cd\u8bd5\u7b56\u7565<\/h5>\n
javascript<\/p>\n
\/\/ \u667a\u80fd\u91cd\u8bd5\u5ba2\u6237\u7aef\u5b9e\u73b0
\nclass ResilientHttpClient {
\n constructor(options = {}) {
\n this.defaultOptions = {
\n maxRetries: 3,
\n baseDelay: 1000, \/\/ 1\u79d2
\n maxDelay: 10000, \/\/ 10\u79d2
\n retryOnStatus: [502, 503, 504],
\n retryOnNetworkError: true,
\n timeout: 30000,
\n …options
\n };<\/p>\nthis.circuitBreakers = new Map();
\n this.metrics = {
\n totalRequests: 0,
\n successfulRequests: 0,
\n failedRequests: 0,
\n retriedRequests: 0,
\n circuitBreakerTrips: 0
\n };
\n }<\/p>\nasync request(url, options = {}) {
\n const requestOptions = { …this.defaultOptions, …options };
\n const requestId = this._generateRequestId();<\/p>\nthis.metrics.totalRequests++;<\/p>\n
\/\/ \u68c0\u67e5\u65ad\u8def\u5668
\n const circuitBreaker = this._getCircuitBreaker(url);
\n if (circuitBreaker.state === 'OPEN') {
\n this.metrics.circuitBreakerTrips++;
\n throw new CircuitBreakerOpenError(
\n `Circuit breaker open for ${url}`,
\n circuitBreaker.lastFailureTime
\n );
\n }<\/p>\nlet lastError;
\n let attempt = 0;<\/p>\nwhile (attempt <= requestOptions.maxRetries) {
\n attempt++;<\/p>\nif (attempt > 1) {
\n this.metrics.retriedRequests++;<\/p>\n\/\/ \u8ba1\u7b97\u9000\u907f\u5ef6\u8fdf
\n const delay = this._calculateBackoff(
\n attempt,
\n requestOptions.baseDelay,
\n requestOptions.maxDelay,
\n lastError
\n );<\/p>\nawait this._delay(delay);
\n }<\/p>\ntry {
\n const controller = new AbortController();
\n const timeoutId = setTimeout(
\n () => controller.abort(),
\n requestOptions.timeout
\n );<\/p>\nconst response = await fetch(url, {
\n …requestOptions,
\n signal: controller.signal,
\n headers: {
\n …requestOptions.headers,
\n 'X-Request-ID': requestId,
\n 'X-Retry-Attempt': attempt.toString()
\n }
\n });<\/p>\nclearTimeout(timeoutId);<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u9700\u8981\u91cd\u8bd5
\n if (this._shouldRetry(response, attempt, requestOptions)) {
\n lastError = new HttpError(
\n `HTTP ${response.status}`,
\n response.status,
\n response
\n );<\/p>\n\/\/ \u4ece\u54cd\u5e94\u4e2d\u83b7\u53d6Retry-After
\n const retryAfter = response.headers.get('Retry-After');
\n if (retryAfter) {
\n await this._delay(parseInt(retryAfter) * 1000);
\n }<\/p>\ncontinue;
\n }<\/p>\n\/\/ \u6210\u529f\u54cd\u5e94
\n circuitBreaker.recordSuccess();
\n this.metrics.successfulRequests++;<\/p>\nreturn response;<\/p>\n
} catch (error) {
\n clearTimeout(timeoutId);
\n lastError = error;<\/p>\n\/\/ \u8bb0\u5f55\u5931\u8d25
\n circuitBreaker.recordFailure();<\/p>\n\/\/ \u68c0\u67e5\u662f\u5426\u5e94\u8be5\u91cd\u8bd5
\n if (!this._shouldRetryOnError(error, attempt, requestOptions)) {
\n break;
\n }
\n }
\n }<\/p>\n\/\/ \u6240\u6709\u91cd\u8bd5\u5931\u8d25
\n this.metrics.failedRequests++;
\n throw new MaxRetriesExceededError(
\n `Max retries (${requestOptions.maxRetries}) exceeded`,
\n lastError,
\n attempt
\n );
\n }<\/p>\n_shouldRetry(response, attempt, options) {
\n if (attempt >= options.maxRetries) {
\n return false;
\n }<\/p>\n\/\/ \u68c0\u67e5\u72b6\u6001\u7801
\n if (options.retryOnStatus.includes(response.status)) {
\n return true;
\n }<\/p>\n\/\/ \u7279\u6b8a\u5904\u7406503\u54cd\u5e94
\n if (response.status === 503) {
\n const retryAfter = response.headers.get('Retry-After');
\n if (retryAfter) {
\n \/\/ \u670d\u52a1\u5668\u660e\u786e\u544a\u8bc9\u6211\u4eec\u5e94\u8be5\u4f55\u65f6\u91cd\u8bd5
\n return true;
\n }<\/p>\n\/\/ \u68c0\u67e5\u54cd\u5e94\u4f53\u662f\u5426\u8868\u660e\u4e34\u65f6\u6545\u969c
\n try {
\n \/\/ \u53ef\u4ee5\u89e3\u6790\u54cd\u5e94\u4f53\u83b7\u53d6\u66f4\u591a\u4fe1\u606f
\n return true;
\n } catch {
\n return false;
\n }
\n }<\/p>\nreturn false;
\n }<\/p>\n_calculateBackoff(attempt, baseDelay, maxDelay, error) {
\n \/\/ \u6307\u6570\u9000\u907f
\n let delay = baseDelay * Math.pow(2, attempt – 1);<\/p>\n\/\/ \u6dfb\u52a0\u968f\u673a\u6296\u52a8
\n delay *= 0.8 + Math.random() * 0.4;<\/p>\n\/\/ \u9650\u5236\u6700\u5927\u5ef6\u8fdf
\n delay = Math.min(delay, maxDelay);<\/p>\n\/\/ \u5bf9\u4e8e503\u54cd\u5e94，\u5982\u679c\u63d0\u4f9b\u4e86Retry-After，\u4f7f\u7528\u5b83
\n if (error && error.status === 503) {
\n const retryAfter = error.response?.headers?.get('Retry-After');
\n if (retryAfter) {
\n const serverDelay = parseInt(retryAfter) * 1000;
\n if (!isNaN(serverDelay)) {
\n delay = Math.max(delay, serverDelay);
\n }
\n }
\n }<\/p>\nreturn Math.round(delay);
\n }<\/p>\n_getCircuitBreaker(url) {
\n const hostname = new URL(url).hostname;<\/p>\nif (!this.circuitBreakers.has(hostname)) {
\n this.circuitBreakers.set(hostname, new CircuitBreaker());
\n }<\/p>\nreturn this.circuitBreakers.get(hostname);
\n }
\n}<\/p>\nclass CircuitBreaker {
\n constructor() {
\n this.state = 'CLOSED';
\n this.failureCount = 0;
\n this.successCount = 0;
\n this.lastFailureTime = null;
\n this.halfOpenTimer = null;<\/p>\nthis.config = {
\n failureThreshold: 5,
\n successThreshold: 3,
\n timeout: 30000
\n };
\n }<\/p>\nrecordSuccess() {
\n this.successCount++;
\n this.failureCount = 0;<\/p>\nif (this.state === 'HALF_OPEN' &&
\n this.successCount >= this.config.successThreshold) {
\n this.state = 'CLOSED';
\n this.successCount = 0;
\n clearTimeout(this.halfOpenTimer);
\n }
\n }<\/p>\nrecordFailure() {
\n this.failureCount++;
\n this.successCount = 0;
\n this.lastFailureTime = Date.now();<\/p>\nif (this.state === 'CLOSED' &&
\n this.failureCount >= this.config.failureThreshold) {
\n this.state = 'OPEN';<\/p>\n\/\/ \u8bbe\u7f6e\u534a\u5f00\u72b6\u6001\u5b9a\u65f6\u5668
\n this.halfOpenTimer = setTimeout(() => {
\n this.state = 'HALF_OPEN';
\n }, this.config.timeout);
\n }
\n }
\n}<\/p>\n27.5 \u7ef4\u62a4\u7a97\u53e3\u4e0e\u8ba1\u5212\u505c\u673a\u7ba1\u7406<\/h4>\n
27.5.1 \u81ea\u52a8\u5316\u7ef4\u62a4\u534f\u8c03\u7cfb\u7edf<\/h5>\n
python<\/p>\n
# \u7ef4\u62a4\u7a97\u53e3\u7ba1\u7406\u5668
\nfrom datetime import datetime, timedelta
\nfrom typing import List, Dict, Optional
\nfrom enum import Enum
\nimport asyncio
\nfrom pydantic import BaseModel, validator<\/p>\nclass MaintenanceType(Enum):
\n PLANNED = "planned"
\n EMERGENCY = "emergency"
\n ROLLING = "rolling"
\n DATABASE = "database"<\/p>\nclass MaintenanceWindow(BaseModel):
\n id: str
\n type: MaintenanceType
\n start_time: datetime
\n end_time: datetime
\n duration_minutes: int
\n description: str
\n affected_services: List[str]
\n notification_channels: List[str]
\n status: str = "scheduled"<\/p>\n@validator('end_time')
\n def validate_duration(cls, end_time, values):
\n if 'start_time' in values:
\n if end_time <= values['start_time']:
\n raise ValueError('End time must be after start time')<\/p>\nduration = (end_time – values['start_time']).total_seconds() \/ 60
\n if duration > 240: # 4\u5c0f\u65f6
\n raise ValueError('Maintenance window cannot exceed 4 hours')<\/p>\nreturn end_time<\/p>\n
class MaintenanceCoordinator:
\n def __init__(self):
\n self.scheduled_windows: Dict[str, MaintenanceWindow] = {}
\n self.active_windows: Dict[str, MaintenanceWindow] = {}
\n self.service_dependencies = self._load_dependencies()<\/p>\nasync def schedule_maintenance(self, window: MaintenanceWindow):
\n """\u8ba1\u5212\u7ef4\u62a4\u7a97\u53e3"""<\/p>\n# \u68c0\u67e5\u51b2\u7a81
\n conflicts = self._find_conflicts(window)
\n if conflicts:
\n raise ValueError(f"Conflicts with existing windows: {conflicts}")<\/p>\n# \u68c0\u67e5\u4f9d\u8d56\u670d\u52a1
\n unavailable_services = self._check_dependencies(window)
\n if unavailable_services:
\n raise ValueError(f"Dependency services unavailable: {unavailable_services}")<\/p>\n# \u5b89\u6392\u7ef4\u62a4
\n self.scheduled_windows[window.id] = window<\/p>\n# \u53d1\u9001\u901a\u77e5
\n await self._send_notifications(window, "scheduled")<\/p>\n# \u8bbe\u7f6e\u5b9a\u65f6\u5668
\n delay = (window.start_time – datetime.now()).total_seconds()
\n if delay > 0:
\n asyncio.create_task(self._start_maintenance(window.id, delay))<\/p>\nreturn window<\/p>\n
async def _start_maintenance(self, window_id: str, delay: float):
\n """\u5f00\u59cb\u7ef4\u62a4\u7a97\u53e3"""
\n await asyncio.sleep(delay)<\/p>\nwindow = self.scheduled_windows.get(window_id)
\n if not window:
\n return<\/p>\n# \u66f4\u65b0\u72b6\u6001
\n window.status = "in_progress"
\n self.active_windows[window_id] = window<\/p>\n# \u5f00\u59cb\u670d\u52a1\u964d\u7ea7
\n await self._initiate_service_degradation(window)<\/p>\n# \u53d1\u9001\u5f00\u59cb\u901a\u77e5
\n await self._send_notifications(window, "started")<\/p>\n# \u8bbe\u7f6e\u7ed3\u675f\u5b9a\u65f6\u5668
\n duration = (window.end_time – window.start_time).total_seconds()
\n asyncio.create_task(self._end_maintenance(window_id, duration))<\/p>\nasync def _end_maintenance(self, window_id: str, delay: float):
\n """\u7ed3\u675f\u7ef4\u62a4\u7a97\u53e3"""
\n await asyncio.sleep(delay)<\/p>\nwindow = self.active_windows.get(window_id)
\n if not window:
\n return<\/p>\n# \u66f4\u65b0\u72b6\u6001
\n window.status = "completed"<\/p>\n# \u6062\u590d\u670d\u52a1
\n await self._restore_services(window)<\/p>\n# \u6e05\u7406
\n del self.active_windows[window_id]
\n del self.scheduled_windows[window_id]<\/p>\n# \u53d1\u9001\u5b8c\u6210\u901a\u77e5
\n await self._send_notifications(window, "completed")<\/p>\n# \u8fd0\u884c\u9a8c\u8bc1\u6d4b\u8bd5
\n await self._run_post_maintenance_tests(window)<\/p>\nasync def _initiate_service_degradation(self, window: MaintenanceWindow):
\n """\u542f\u52a8\u670d\u52a1\u964d\u7ea7\u6d41\u7a0b"""<\/p>\nfor service in window.affected_services:
\n # \u53d1\u9001\u4f18\u96c5\u5173\u95ed\u4fe1\u53f7
\n await self._graceful_shutdown(service)<\/p>\n# \u8bbe\u7f6e\u5065\u5eb7\u68c0\u67e5\u4e3a\u4e0d\u5065\u5eb7
\n await self._update_health_check(service, False)<\/p>\n# \u4ece\u8d1f\u8f7d\u5747\u8861\u5668\u4e2d\u79fb\u9664
\n await self._remove_from_load_balancer(service)<\/p>\n# \u53d1\u9001503\u54cd\u5e94
\n await self._enable_maintenance_mode(service, window)<\/p>\nasync def _enable_maintenance_mode(self, service: str, window: MaintenanceWindow):
\n """\u542f\u7528\u7ef4\u62a4\u6a21\u5f0f"""<\/p>\nmaintenance_response = {
\n "status": 503,
\n "headers": {
\n "Content-Type": "application\/json",
\n "Retry-After": self._calculate_retry_after(window),
\n "X-Maintenance-ID": window.id,
\n "X-Maintenance-End": window.end_time.isoformat()
\n },
\n "body": {
\n "error": {
\n "code": "maintenance_mode",
\n "message": "Service is undergoing maintenance",
\n "details": {
\n "maintenance_id": window.id,
\n "start_time": window.start_time.isoformat(),
\n "estimated_end_time": window.end_time.isoformat(),
\n "description": window.description,
\n "status_page": "https:\/\/status.example.com",
\n "updates_channel": "https:\/\/updates.example.com\/maintenance"
\n }
\n }
\n }
\n }<\/p>\n# \u5e94\u7528\u7ef4\u62a4\u6a21\u5f0f\u54cd\u5e94
\n await self._apply_maintenance_response(service, maintenance_response)<\/p>\ndef _calculate_retry_after(self, window: MaintenanceWindow) -> str:
\n """\u8ba1\u7b97Retry-After\u5934\u90e8\u503c"""
\n remaining = window.end_time – datetime.now()
\n minutes = max(1, int(remaining.total_seconds() \/ 60))
\n return str(min(minutes, 60)) # \u6700\u591a60\u5206\u949f<\/p>\nasync def _send_notifications(self, window: MaintenanceWindow, event: str):
\n """\u53d1\u9001\u7ef4\u62a4\u901a\u77e5"""<\/p>\nnotifications = {
\n "scheduled": {
\n "title": "🛠\ufe0f \u8ba1\u5212\u7ef4\u62a4\u901a\u77e5",
\n "message": f"\u670d\u52a1 {', '.join(window.affected_services)} \u8ba1\u5212\u4e8e "
\n f"{window.start_time.strftime('%Y-%m-%d %H:%M')} \u8fdb\u884c\u7ef4\u62a4\u3002",
\n "priority": "medium"
\n },
\n "started": {
\n "title": "🔧 \u7ef4\u62a4\u5df2\u5f00\u59cb",
\n "message": f"\u7ef4\u62a4\u5df2\u5f00\u59cb，\u9884\u8ba1\u6301\u7eed {window.duration_minutes} \u5206\u949f\u3002",
\n "priority": "high"
\n },
\n "completed": {
\n "title": "\u2705 \u7ef4\u62a4\u5df2\u5b8c\u6210",
\n "message": "\u7ef4\u62a4\u5df2\u5b8c\u6210，\u6240\u6709\u670d\u52a1\u5df2\u6062\u590d\u6b63\u5e38\u3002",
\n "priority": "medium"
\n }
\n }<\/p>\nif event not in notifications:
\n return<\/p>\nnotification = notifications[event]<\/p>\n
# \u53d1\u9001\u5230\u4e0d\u540c\u6e20\u9053
\n for channel in window.notification_channels:
\n if channel == "email":
\n await self._send_email_notification(window, notification)
\n elif channel == "slack":
\n await self._send_slack_notification(window, notification)
\n elif channel == "webhook":
\n await self._send_webhook_notification(window, notification)<\/p>\ndef _find_conflicts(self, new_window: MaintenanceWindow) -> List[str]:
\n """\u67e5\u627e\u65f6\u95f4\u51b2\u7a81\u7684\u7ef4\u62a4\u7a97\u53e3"""
\n conflicts = []<\/p>\nfor window_id, existing in self.scheduled_windows.items():
\n if (new_window.start_time < existing.end_time and
\n new_window.end_time > existing.start_time):<\/p>\n# \u68c0\u67e5\u662f\u5426\u6709\u670d\u52a1\u91cd\u53e0
\n overlapping_services = set(new_window.affected_services) & \\\\
\n set(existing.affected_services)<\/p>\nif overlapping_services:
\n conflicts.append(f"{window_id}: {', '.join(overlapping_services)}")<\/p>\nreturn conflicts<\/p>\n
27.6 \u6700\u4f73\u5b9e\u8df5\u603b\u7ed3<\/h4>\n
27.6.1 \u5bb9\u91cf\u89c4\u5212\u6307\u5357<\/h5>\n
- \n
\u57fa\u51c6\u6d4b\u8bd5：<\/p>\n
bash<\/p>\n
# \u4f7f\u7528wrk\u8fdb\u884c\u8d1f\u8f7d\u6d4b\u8bd5
\nwrk -t12 -c400 -d30s –latency https:\/\/api.example.com<\/p>\n# \u5173\u952e\u6307\u6807：
\n# – \u6700\u5927QPS（\u6bcf\u79d2\u67e5\u8be2\u6570）
\n# – 95%\u54cd\u5e94\u65f6\u95f4
\n# – \u9519\u8bef\u7387\n<\/li>\n - \n
\u5bb9\u91cf\u516c\u5f0f：<\/p>\n
text<\/p>\n
\u6240\u9700\u5b9e\u4f8b\u6570 = (\u9884\u671fQPS \u00d7 \u5e73\u5747\u54cd\u5e94\u65f6\u95f4) \/ \u76ee\u6807\u5229\u7528\u7387<\/p>\n
\u793a\u4f8b：
\n\u9884\u671fQPS = 1000
\n\u5e73\u5747\u54cd\u5e94\u65f6\u95f4 = 0.1\u79d2
\n\u76ee\u6807\u5229\u7528\u7387 = 0.7<\/p>\n\u6240\u9700\u5b9e\u4f8b\u6570 = (1000 \u00d7 0.1) \/ 0.7 \u2248 143\u4e2a\u8fde\u63a5\n<\/li>\n
27.6.2 \u964d\u7ea7\u7b56\u7565\u77e9\u9635<\/h5>\n
\n
\u964d\u7ea7\u7ea7\u522b\u529f\u80fd\u53ef\u7528\u6027\u54cd\u5e94\u65f6\u95f4\u7528\u6237\u4f53\u9a8c\u4e1a\u52a1\u5f71\u54cd<\/tr>\n \n\n \u6b63\u5e38<\/td>\n 100%\u529f\u80fd<\/td>\n <200ms<\/td>\n \u5b8c\u6574\u4f53\u9a8c<\/td>\n \u65e0\u5f71\u54cd<\/td>\n<\/tr>\n \n \u964d\u7ea7<\/td>\n \u6838\u5fc3\u529f\u80fd<\/td>\n <500ms<\/td>\n \u90e8\u5206\u53d7\u9650<\/td>\n \u4f4e\u5f71\u54cd<\/td>\n<\/tr>\n \n \u6700\u5c0f<\/td>\n \u5173\u952e\u529f\u80fd<\/td>\n <1000ms<\/td>\n \u57fa\u672c\u53ef\u7528<\/td>\n \u4e2d\u5f71\u54cd<\/td>\n<\/tr>\n \n \u7d27\u6025<\/td>\n \u53ea\u8bfb\u529f\u80fd<\/td>\n N\/A<\/td>\n \u9759\u6001\u9875\u9762<\/td>\n \u9ad8\u5f71\u54cd<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n 27.6.3 \u76d1\u63a7\u544a\u8b66\u9608\u503c<\/h5>\n
text<\/p>\n
\u2705 \u9519\u8bef\u7387\u544a\u8b66：> 1% \u6301\u7eed5\u5206\u949f
\n\u2705 \u54cd\u5e94\u65f6\u95f4\u544a\u8b66：P95 > 500ms \u6301\u7eed10\u5206\u949f
\n\u2705 \u961f\u5217\u957f\u5ea6\u544a\u8b66：> 1000 \u6301\u7eed2\u5206\u949f
\n\u2705 CPU\u4f7f\u7528\u7387\u544a\u8b66：> 80% \u6301\u7eed5\u5206\u949f
\n\u2705 \u5185\u5b58\u4f7f\u7528\u7387\u544a\u8b66：> 90% \u6301\u7eed2\u5206\u949f<\/p>\n\u901a\u8fc7\u5b9e\u65bd\u8fd9\u4e9b\u7b56\u7565，\u53ef\u4ee5\u6709\u6548\u5730\u7ba1\u7406\u670d\u52a1\u4e0d\u53ef\u7528\u60c5\u51b5，\u63d0\u4f9b\u66f4\u597d\u7684\u7528\u6237\u4f53\u9a8c，\u540c\u65f6\u786e\u4fdd\u7cfb\u7edf\u7684\u7a33\u5b9a\u6027\u548c\u53ef\u9760\u6027\u3002<\/p>\n
\n\u7b2c28\u7ae0：504 Gateway Timeout – \u7f51\u5173\u8d85\u65f6<\/h3>\n
28.1 \u6df1\u5ea6\u89e3\u6790\u7f51\u5173\u8d85\u65f6\u673a\u5236<\/h4>\n
504 Gateway Timeout\u00a0\u8868\u793a\u7f51\u5173\u6216\u4ee3\u7406\u670d\u52a1\u5668\u672a\u80fd\u53ca\u65f6\u4ece\u4e0a\u6e38\u670d\u52a1\u5668\u6536\u5230\u54cd\u5e94\u3002\u8fd9\u662f\u5206\u5e03\u5f0f\u7cfb\u7edf\u4e2d\u5e38\u89c1\u7684\u8d85\u65f6\u9519\u8bef，\u901a\u5e38\u7531\u7f51\u7edc\u5ef6\u8fdf\u6216\u4e0a\u6e38\u670d\u52a1\u5904\u7406\u7f13\u6162\u5f15\u8d77\u3002<\/p>\n
28.1.1 \u534f\u8bae\u89c4\u8303\u4e0e\u8d85\u65f6\u8bed\u4e49<\/h5>\n
- \n
- \n
RFC 7231\u5b9a\u4e49：\u670d\u52a1\u5668\u4f5c\u4e3a\u7f51\u5173\u6216\u4ee3\u7406，\u672a\u80fd\u53ca\u65f6\u4ece\u4e0a\u6e38\u670d\u52a1\u5668\u6536\u5230\u54cd\u5e94<\/p>\n<\/li>\n
- \n
\u5173\u952e\u7279\u5f81：<\/p>\n
- \n
- \n
\u8d85\u65f6\u53d1\u751f\u5728\u7f51\u5173\u5c42\u9762<\/p>\n<\/li>\n
- \n
\u4e0a\u6e38\u670d\u52a1\u5668\u53ef\u80fd\u4ecd\u5728\u5904\u7406\u8bf7\u6c42<\/p>\n<\/li>\n
- \n
\u4e0e502 Bad Gateway\u7684\u4e3b\u8981\u533a\u522b：502\u662f\u8fde\u63a5\u5931\u8d25，504\u662f\u54cd\u5e94\u8d85\u65f6<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
28.1.2 \u5206\u5e03\u5f0f\u7cfb\u7edf\u4e2d\u7684\u8d85\u65f6\u4f20\u64ad
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/07\/20260726181701-6a664f1d954a1.png\")
<\/h5>\n28.2 \u8d85\u65f6\u914d\u7f6e\u4e0e\u4f18\u5316\u7b56\u7565<\/h4>\n
28.2.1 \u591a\u5c42\u8d85\u65f6\u914d\u7f6e\u6a21\u578b<\/h5>\n
yaml<\/p>\n
# \u5206\u5e03\u5f0f\u8d85\u65f6\u914d\u7f6e\u7ba1\u7406
\ntimeout_config:
\n # \u5168\u5c40\u9ed8\u8ba4\u914d\u7f6e
\n defaults:
\n connect_timeout: 5s
\n read_timeout: 30s
\n write_timeout: 30s
\n total_timeout: 60s<\/p>\n# \u670d\u52a1\u7ea7\u914d\u7f6e
\n services:
\n user_service:
\n endpoint: "\/api\/v1\/users"
\n timeouts:
\n connect: 2s
\n read: 10s
\n write: 10s
\n total: 15s
\n retry_policy:
\n max_attempts: 3
\n backoff_base: 1s
\n backoff_max: 10s<\/p>\npayment_service:
\n endpoint: "\/api\/v1\/payments"
\n timeouts:
\n connect: 5s
\n read: 60s # \u652f\u4ed8\u5904\u7406\u53ef\u80fd\u8f83\u957f
\n write: 30s
\n total: 90s
\n circuit_breaker:
\n failure_threshold: 5
\n success_threshold: 3
\n timeout: 30s<\/p>\nsearch_service:
\n endpoint: "\/api\/v1\/search"
\n timeouts:
\n connect: 1s
\n read: 5s # \u641c\u7d22\u9700\u8981\u5feb\u901f\u54cd\u5e94
\n write: 2s
\n total: 10s
\n fallback:
\n enabled: true
\n timeout: 2s
\n response: "cached_results"<\/p>\n# \u4f9d\u8d56\u7ea7\u914d\u7f6e
\n dependencies:
\n database:
\n primary:
\n connect_timeout: 3s
\n query_timeout: 10s
\n transaction_timeout: 30s
\n replica:
\n connect_timeout: 5s
\n query_timeout: 15s
\n read_only: true<\/p>\ncache:
\n redis:
\n connect_timeout: 1s
\n operation_timeout: 2s
\n pool_timeout: 5s<\/p>\nmemcached:
\n connect_timeout: 1s
\n operation_timeout: 2s<\/p>\nexternal_apis:
\n payment_gateway:
\n timeout: 30s
\n retry_count: 2<\/p>\nemail_service:
\n timeout: 10s
\n async: true # \u53ef\u4ee5\u5f02\u6b65\u5904\u7406<\/p>\nanalytics:
\n timeout: 5s
\n fire_and_forget: true # \u975e\u5173\u952e\u8def\u5f84<\/p>\n# \u81ea\u9002\u5e94\u8d85\u65f6\u914d\u7f6e
\n adaptive:
\n enabled: true
\n sampling_rate: 0.1 # 10%\u7684\u8bf7\u6c42\u7528\u4e8e\u5b66\u4e60
\n history_window: "5m"
\n percentiles:
\n – 95 # P95\u54cd\u5e94\u65f6\u95f4
\n – 99 # P99\u54cd\u5e94\u65f6\u95f4<\/p>\nadjustment:
\n min_timeout: "100ms"
\n max_timeout: "300s"
\n adjustment_factor: 1.5 # \u57fa\u4e8eP99\u76841.5\u500d
\n cooldown_period: "30s"<\/p>\n28.2.2 Nginx\u8d85\u65f6\u4f18\u5316\u914d\u7f6e<\/h5>\n
nginx<\/p>\n
# Nginx\u9ad8\u7ea7\u8d85\u65f6\u914d\u7f6e
\nhttp {
\n # \u5168\u5c40\u8d85\u65f6\u8bbe\u7f6e
\n keepalive_timeout 75s;
\n keepalive_requests 1000;<\/p>\n# \u89e3\u6790\u8d85\u65f6
\n resolver 8.8.8.8 8.8.4.4 valid=300s;
\n resolver_timeout 5s;<\/p>\n# \u5ba2\u6237\u7aef\u8d85\u65f6
\n client_body_timeout 60s;
\n client_header_timeout 60s;
\n send_timeout 60s;<\/p>\n# \u9650\u5236\u5ba2\u6237\u7aef\u8bf7\u6c42\u5927\u5c0f
\n client_max_body_size 100m;<\/p>\nupstream backend {
\n server 10.0.1.1:8080;
\n server 10.0.1.2:8080;<\/p>\n# \u8fde\u63a5\u6c60\u914d\u7f6e
\n keepalive 100;
\n keepalive_timeout 60s;
\n keepalive_requests 1000;
\n }<\/p>\nserver {
\n listen 80;<\/p>\nlocation \/api\/ {
\n proxy_pass http:\/\/backend;<\/p>\n# \u4ee3\u7406\u8d85\u65f6\u8bbe\u7f6e
\n proxy_connect_timeout 5s;
\n proxy_send_timeout 30s;
\n proxy_read_timeout 30s;<\/p>\n# \u7f13\u51b2\u8bbe\u7f6e
\n proxy_buffering on;
\n proxy_buffer_size 8k;
\n proxy_buffers 16 8k;
\n proxy_busy_buffers_size 16k;
\n proxy_temp_file_write_size 16k;<\/p>\n# \u91cd\u8bd5\u914d\u7f6e
\n proxy_next_upstream error timeout invalid_header http_502 http_503 http_504;
\n proxy_next_upstream_tries 3;
\n proxy_next_upstream_timeout 10s;<\/p>\n# \u8d85\u65f6\u9519\u8bef\u5904\u7406
\n proxy_intercept_errors on;
\n error_page 504 = @gateway_timeout;
\n }<\/p>\n# \u81ea\u5b9a\u4e49504\u5904\u7406
\n location @gateway_timeout {
\n default_type application\/json;<\/p>\n# \u6dfb\u52a0\u91cd\u8bd5\u5934\u90e8
\n add_header Retry-After 30;
\n add_header X-Request-ID $request_id;
\n add_header X-Upstream-Timeout "true";<\/p>\n# \u8fd4\u56deJSON\u9519\u8bef\u54cd\u5e94
\n return 504 '{
\n "error": {
\n "code": "gateway_timeout",
\n "message": "Upstream server did not respond in time",
\n "request_id": "$request_id",
\n "timestamp": "$time_iso8601",
\n "upstream": "$proxy_host",
\n "suggested_actions": [
\n "Please retry your request",
\n "Check service status at status.example.com",
\n "Contact support if the issue persists"
\n ]
\n }
\n }';
\n }<\/p>\n# \u6162\u8bf7\u6c42\u65e5\u5fd7\u8bb0\u5f55
\n log_format slow_requests '$remote_addr – $remote_user [$time_local] '
\n '"$request" $status $body_bytes_sent '
\n '"$http_referer" "$http_user_agent" '
\n '$request_time $upstream_response_time '
\n '$upstream_addr $upstream_status';<\/p>\naccess_log \/var\/log\/nginx\/slow_requests.log slow_requests
\n if=$slow_request;<\/p>\n# \u5b9a\u4e49\u6162\u8bf7\u6c42（\u8d85\u8fc75\u79d2）
\n map $request_time $slow_request {
\n default 0;
\n "~^[5-9]\\\\." 1; # 5-9\u79d2
\n "~^[1-9][0-9]" 1; # 10\u79d2\u4ee5\u4e0a
\n }
\n }
\n}<\/p>\n28.3 \u667a\u80fd\u8d85\u65f6\u7ba1\u7406<\/h4>\n
28.3.1 \u81ea\u9002\u5e94\u8d85\u65f6\u7b97\u6cd5<\/h5>\n
python<\/p>\n
# \u81ea\u9002\u5e94\u8d85\u65f6\u7ba1\u7406\u7cfb\u7edf
\nimport time
\nimport statistics
\nfrom typing import List, Dict, Optional
\nfrom collections import deque
\nfrom dataclasses import dataclass
\nfrom datetime import datetime, timedelta
\nimport numpy as np<\/p>\n@dataclass
\nclass TimeoutMetrics:
\n """\u8d85\u65f6\u6307\u6807"""
\n p50_response_time: float
\n p95_response_time: float
\n p99_response_time: float
\n success_rate: float
\n timeout_rate: float
\n total_requests: int
\n sample_size: int<\/p>\nclass AdaptiveTimeoutManager:
\n """\u81ea\u9002\u5e94\u8d85\u65f6\u7ba1\u7406\u5668"""<\/p>\ndef __init__(self, service_name: str, initial_timeout: float = 30.0):
\n self.service_name = service_name
\n self.base_timeout = initial_timeout
\n self.current_timeout = initial_timeout
\n self.min_timeout = 0.1 # 100ms
\n self.max_timeout = 300.0 # 5\u5206\u949f<\/p>\n# \u5386\u53f2\u6570\u636e\u5b58\u50a8
\n self.response_times: deque = deque(maxlen=10000)
\n self.timeout_history: deque = deque(maxlen=1000)
\n self.metrics_history: deque = deque(maxlen=100)<\/p>\n# \u81ea\u9002\u5e94\u53c2\u6570
\n self.percentile_target = 99 # \u57fa\u4e8eP99\u8c03\u6574
\n self.safety_factor = 1.5 # \u5b89\u5168\u7cfb\u6570
\n self.adjustment_cooldown = 30 # \u8c03\u6574\u51b7\u5374\u65f6\u95f4（\u79d2）
\n self.last_adjustment = 0<\/p>\n# \u7edf\u8ba1\u5468\u671f
\n self.window_size = 300 # 5\u5206\u949f\u7a97\u53e3<\/p>\ndef record_response(self, response_time: float, timed_out: bool = False):
\n """\u8bb0\u5f55\u54cd\u5e94\u65f6\u95f4"""
\n self.response_times.append({
\n 'timestamp': time.time(),
\n 'response_time': response_time,
\n 'timed_out': timed_out
\n })<\/p>\nif timed_out:
\n self.timeout_history.append(time.time())<\/p>\n# \u5b9a\u671f\u8c03\u6574\u8d85\u65f6\u65f6\u95f4
\n if time.time() – self.last_adjustment > self.adjustment_cooldown:
\n self._adjust_timeout()<\/p>\ndef _adjust_timeout(self):
\n """\u8c03\u6574\u8d85\u65f6\u65f6\u95f4"""
\n current_time = time.time()<\/p>\n# \u83b7\u53d6\u7a97\u53e3\u5185\u7684\u6570\u636e
\n window_start = current_time – self.window_size
\n recent_responses = [
\n r for r in self.response_times
\n if r['timestamp'] > window_start
\n ]<\/p>\nif len(recent_responses) < 100: # \u6700\u5c11100\u4e2a\u6837\u672c
\n return<\/p>\n# \u8ba1\u7b97\u7edf\u8ba1\u6307\u6807
\n response_times = [r['response_time'] for r in recent_responses]
\n timeouts = sum(1 for r in recent_responses if r['timed_out'])<\/p>\nif not response_times:
\n return<\/p>\n# \u8ba1\u7b97\u767e\u5206\u4f4d\u6570
\n try:
\n p95 = np.percentile(response_times, 95)
\n p99 = np.percentile(response_times, 99)<\/p>\n# \u8ba1\u7b97\u6210\u529f\u7387
\n success_rate = 1 – (timeouts \/ len(recent_responses))<\/p>\n# \u57fa\u4e8eP99\u548c\u5b89\u5168\u7cfb\u6570\u8ba1\u7b97\u65b0\u8d85\u65f6\u65f6\u95f4
\n new_timeout = p99 * self.safety_factor<\/p>\n# \u5e94\u7528\u8fb9\u754c\u6761\u4ef6
\n new_timeout = max(self.min_timeout, min(new_timeout, self.max_timeout))<\/p>\n# \u907f\u514d\u9891\u7e41\u8c03\u6574（\u53d8\u5316\u5c0f\u4e8e10%\u65f6\u4e0d\u8c03\u6574）
\n if abs(new_timeout – self.current_timeout) \/ self.current_timeout > 0.1:
\n old_timeout = self.current_timeout
\n self.current_timeout = new_timeout
\n self.last_adjustment = current_time<\/p>\n# \u8bb0\u5f55\u8c03\u6574
\n self._log_adjustment(old_timeout, new_timeout, p95, p99, success_rate)<\/p>\nexcept Exception as e:
\n print(f"Error adjusting timeout: {e}")<\/p>\ndef get_timeout_for_percentile(self, percentile: int = 95) -> float:
\n """\u83b7\u53d6\u7279\u5b9a\u767e\u5206\u4f4d\u7684\u63a8\u8350\u8d85\u65f6\u65f6\u95f4"""
\n if not self.response_times:
\n return self.base_timeout<\/p>\nrecent_responses = list(self.response_times)
\n if len(recent_responses) < 10:
\n return self.base_timeout<\/p>\nresponse_times = [r['response_time'] for r in recent_responses
\n if not r['timed_out']]<\/p>\nif not response_times:
\n return self.base_timeout<\/p>\ntry:
\n target_percentile = np.percentile(response_times, percentile)
\n return target_percentile * self.safety_factor
\n except:
\n return self.base_timeout<\/p>\ndef should_use_percentile_timeout(self, request_type: str) -> bool:
\n """\u5224\u65ad\u662f\u5426\u5e94\u8be5\u4f7f\u7528\u767e\u5206\u4f4d\u8d85\u65f6"""
\n # \u67d0\u4e9b\u8bf7\u6c42\u7c7b\u578b\u4f7f\u7528\u56fa\u5b9a\u8d85\u65f6
\n fixed_timeout_types = ['login', 'health_check', 'metrics']<\/p>\nif request_type in fixed_timeout_types:
\n return False<\/p>\n# \u68c0\u67e5\u662f\u5426\u6709\u8db3\u591f\u7684\u5386\u53f2\u6570\u636e
\n if len(self.response_times) < 100:
\n return False<\/p>\n# \u68c0\u67e5\u6570\u636e\u8d28\u91cf（\u54cd\u5e94\u65f6\u95f4\u65b9\u5dee）
\n recent_responses = list(self.response_times)[-100:]
\n response_times = [r['response_time'] for r in recent_responses
\n if not r['timed_out']]<\/p>\nif len(response_times) < 20:
\n return False<\/p>\n# \u8ba1\u7b97\u53d8\u5f02\u7cfb\u6570（\u6807\u51c6\u5dee\/\u5747\u503c）
\n if statistics.mean(response_times) > 0:
\n coefficient_of_variation = statistics.stdev(response_times) \/ statistics.mean(response_times)
\n # \u5982\u679c\u53d8\u5f02\u7cfb\u6570\u592a\u9ad8，\u4f7f\u7528\u4fdd\u5b88\u8d85\u65f6
\n if coefficient_of_variation > 2.0:
\n return False<\/p>\nreturn True<\/p>\n
def get_dynamic_timeout(self, request_context: Dict) -> float:
\n """\u83b7\u53d6\u52a8\u6001\u8d85\u65f6\u65f6\u95f4"""
\n request_type = request_context.get('type', 'default')<\/p>\n# \u68c0\u67e5\u662f\u5426\u5e94\u8be5\u4f7f\u7528\u767e\u5206\u4f4d\u8d85\u65f6
\n if self.should_use_percentile_timeout(request_type):
\n # \u6839\u636e\u8bf7\u6c42\u590d\u6742\u5ea6\u8c03\u6574\u767e\u5206\u4f4d
\n complexity = request_context.get('complexity', 1.0)
\n adjusted_percentile = min(99, 95 * complexity)<\/p>\ntimeout = self.get_timeout_for_percentile(int(adjusted_percentile))
\n else:
\n # \u4f7f\u7528\u9884\u5b9a\u4e49\u8d85\u65f6
\n timeout_config = {
\n 'health_check': 5.0,
\n 'login': 10.0,
\n 'search': 5.0,
\n 'report': 60.0,
\n 'batch_processing': 300.0,
\n 'default': self.current_timeout
\n }<\/p>\ntimeout = timeout_config.get(request_type, self.current_timeout)<\/p>\n
# \u57fa\u4e8e\u4f18\u5148\u7ea7\u8c03\u6574
\n priority = request_context.get('priority', 'medium')
\n priority_factors = {
\n 'high': 1.0,
\n 'medium': 1.0,
\n 'low': 0.5
\n }<\/p>\ntimeout *= priority_factors.get(priority, 1.0)<\/p>\n
# \u786e\u4fdd\u5728\u5408\u7406\u8303\u56f4\u5185
\n return max(self.min_timeout, min(timeout, self.max_timeout))<\/p>\n28.3.2 \u57fa\u4e8e\u673a\u5668\u5b66\u4e60\u7684\u8d85\u65f6\u9884\u6d4b<\/h5>\n
python<\/p>\n
# \u4f7f\u7528\u673a\u5668\u5b66\u4e60\u9884\u6d4b\u8d85\u65f6
\nimport pandas as pd
\nfrom sklearn.ensemble import RandomForestRegressor
\nfrom sklearn.preprocessing import StandardScaler
\nfrom sklearn.pipeline import Pipeline
\nimport joblib
\nfrom datetime import datetime<\/p>\nclass TimeoutPredictor:
\n """\u57fa\u4e8e\u673a\u5668\u5b66\u4e60\u7684\u8d85\u65f6\u9884\u6d4b\u5668"""<\/p>\ndef __init__(self, model_path: Optional[str] = None):
\n self.features = [
\n 'request_size_kb',
\n 'request_complexity',
\n 'concurrent_requests',
\n 'time_of_day',
\n 'day_of_week',
\n 'service_load',
\n 'network_latency',
\n 'cache_hit_rate',
\n 'database_load',
\n 'previous_response_time'
\n ]<\/p>\nif model_path and os.path.exists(model_path):
\n self.model = joblib.load(model_path)
\n else:
\n self.model = self._build_model()<\/p>\nself.training_data = []
\n self.last_training = datetime.now()<\/p>\ndef _build_model(self) -> Pipeline:
\n """\u6784\u5efa\u673a\u5668\u5b66\u4e60\u7ba1\u9053"""
\n pipeline = Pipeline([
\n ('scaler', StandardScaler()),
\n ('regressor', RandomForestRegressor(
\n n_estimators=100,
\n max_depth=10,
\n min_samples_split=5,
\n random_state=42
\n ))
\n ])
\n return pipeline<\/p>\ndef extract_features(self, request_context: Dict) -> List[float]:
\n """\u4ece\u8bf7\u6c42\u4e0a\u4e0b\u6587\u4e2d\u63d0\u53d6\u7279\u5f81"""
\n features = []<\/p>\nfor feature_name in self.features:
\n value = request_context.get(feature_name, 0.0)<\/p>\n# \u7279\u5f81\u5de5\u7a0b
\n if feature_name == 'time_of_day':
\n # \u5c06\u65f6\u95f4\u8f6c\u6362\u4e3a\u6b63\u5f26\/\u4f59\u5f26\u7279\u5f81
\n hour = value % 24
\n features.append(np.sin(2 * np.pi * hour \/ 24))
\n features.append(np.cos(2 * np.pi * hour \/ 24))
\n elif feature_name == 'day_of_week':
\n # \u661f\u671f\u51e0\u7684\u7f16\u7801
\n features.append(value % 7)
\n features.append(1 if value >= 5 else 0) # \u662f\u5426\u4e3a\u5468\u672b
\n else:
\n features.append(float(value))<\/p>\nreturn features<\/p>\n
def predict_timeout(self, request_context: Dict) -> float:
\n """\u9884\u6d4b\u8bf7\u6c42\u7684\u8d85\u65f6\u65f6\u95f4"""
\n features = self.extract_features(request_context)<\/p>\ntry:
\n # \u8f6c\u6362\u4e3aDataFrame
\n X = pd.DataFrame([features], columns=self.features[:len(features)])<\/p>\n# \u9884\u6d4b
\n prediction = self.model.predict(X)[0]<\/p>\n# \u5e94\u7528\u5b89\u5168\u8fb9\u754c
\n safety_margin = 1.3 # 30%\u7684\u5b89\u5168\u8fb9\u754c
\n predicted_timeout = max(0.1, prediction * safety_margin)<\/p>\nreturn min(predicted_timeout, 300.0) # \u6700\u59275\u5206\u949f<\/p>\n
except Exception as e:
\n # \u5982\u679c\u9884\u6d4b\u5931\u8d25，\u8fd4\u56de\u4fdd\u5b88\u4f30\u8ba1
\n print(f"Prediction failed: {e}")
\n return 30.0 # \u9ed8\u8ba430\u79d2<\/p>\ndef record_training_sample(self, request_context: Dict,
\n actual_response_time: float):
\n """\u8bb0\u5f55\u8bad\u7ec3\u6837\u672c"""
\n features = self.extract_features(request_context)
\n self.training_data.append(features + [actual_response_time])<\/p>\n# \u5b9a\u671f\u91cd\u65b0\u8bad\u7ec3\u6a21\u578b
\n if (datetime.now() – self.last_training).total_seconds() > 3600: # \u6bcf\u5c0f\u65f6
\n self.retrain_model()<\/p>\ndef retrain_model(self):
\n """\u91cd\u65b0\u8bad\u7ec3\u6a21\u578b"""
\n if len(self.training_data) < 100:
\n return<\/p>\ndf = pd.DataFrame(self.training_data,
\n columns=self.features + ['response_time'])<\/p>\nX = df[self.features]
\n y = df['response_time']<\/p>\n# \u79fb\u9664\u5f02\u5e38\u503c
\n Q1 = y.quantile(0.25)
\n Q3 = y.quantile(0.75)
\n IQR = Q3 – Q1
\n mask = (y >= Q1 – 1.5 * IQR) & (y <= Q3 + 1.5 * IQR)<\/p>\nX_clean = X[mask]
\n y_clean = y[mask]<\/p>\nif len(X_clean) < 50:
\n return<\/p>\n# \u8bad\u7ec3\u6a21\u578b
\n self.model.fit(X_clean, y_clean)
\n self.last_training = datetime.now()<\/p>\n# \u4fdd\u5b58\u6a21\u578b
\n joblib.dump(self.model, f'timeout_model_{datetime.now().timestamp()}.joblib')<\/p>\nprint(f"Model retrained with {len(X_clean)} samples")<\/p>\n
28.4 \u5206\u5e03\u5f0f\u8ffd\u8e2a\u4e0e\u8d85\u65f6\u5206\u6790<\/h4>\n
28.4.1 \u96c6\u6210\u5206\u5e03\u5f0f\u8ffd\u8e2a<\/h5>\n
python<\/p>\n
# \u5206\u5e03\u5f0f\u8ffd\u8e2a\u96c6\u6210
\nfrom opentelemetry import trace
\nfrom opentelemetry.trace import Status, StatusCode
\nfrom opentelemetry.sdk.trace import TracerProvider
\nfrom opentelemetry.sdk.trace.export import BatchSpanProcessor
\nfrom opentelemetry.exporter.jaeger.thrift import JaegerExporter
\nimport time<\/p>\nclass TracedTimeoutManager:
\n """\u96c6\u6210\u5206\u5e03\u5f0f\u8ffd\u8e2a\u7684\u8d85\u65f6\u7ba1\u7406\u5668"""<\/p>\ndef __init__(self, service_name: str):
\n # \u8bbe\u7f6eOpenTelemetry
\n trace.set_tracer_provider(TracerProvider())
\n self.tracer = trace.get_tracer(__name__)<\/p>\n# Jaeger\u5bfc\u51fa\u5668
\n jaeger_exporter = JaegerExporter(
\n agent_host_name="jaeger",
\n agent_port=6831,
\n )<\/p>\nspan_processor = BatchSpanProcessor(jaeger_exporter)
\n trace.get_tracer_provider().add_span_processor(span_processor)<\/p>\nself.service_name = service_name
\n self.timeout_thresholds = {
\n 'critical': 1.0, # \u8d85\u8fc71\u79d2\u4e3a\u5173\u952e\u8def\u5f84
\n 'warning': 5.0, # \u8d85\u8fc75\u79d2\u4e3a\u8b66\u544a
\n 'timeout': 30.0 # \u8d85\u65f6\u9608\u503c
\n }<\/p>\ndef instrument_request(self, request_func):
\n """\u88c5\u9970\u5668：\u4e3a\u8bf7\u6c42\u6dfb\u52a0\u8ffd\u8e2a\u548c\u8d85\u65f6\u76d1\u63a7"""
\n def wrapper(*args, **kwargs):
\n request_name = kwargs.get('request_name', 'unknown')<\/p>\nwith self.tracer.start_as_current_span(f"{self.service_name}.{request_name}") as span:
\n # \u6dfb\u52a0\u8bf7\u6c42\u5c5e\u6027
\n span.set_attributes({
\n "http.method": kwargs.get('method', 'GET'),
\n "http.url": kwargs.get('url', ''),
\n "http.request_size": kwargs.get('content_length', 0),
\n "timeout.threshold": kwargs.get('timeout', 30.0)
\n })<\/p>\nstart_time = time.time()<\/p>\n
try:
\n # \u6267\u884c\u8bf7\u6c42
\n result = request_func(*args, **kwargs)<\/p>\n# \u8ba1\u7b97\u54cd\u5e94\u65f6\u95f4
\n response_time = time.time() – start_time<\/p>\n# \u8bb0\u5f55\u6027\u80fd\u6307\u6807
\n self._record_performance_metrics(span, response_time,
\n kwargs.get('timeout', 30.0))<\/p>\n# \u6dfb\u52a0\u54cd\u5e94\u5c5e\u6027
\n if hasattr(result, 'status_code'):
\n span.set_attribute("http.status_code", result.status_code)<\/p>\nspan.set_status(Status(StatusCode.OK))<\/p>\n
return result<\/p>\n
except TimeoutError as e:
\n # \u5904\u7406\u8d85\u65f6
\n response_time = time.time() – start_time<\/p>\nspan.set_status(Status(
\n StatusCode.ERROR,
\n f"Timeout after {response_time:.2f}s"
\n ))<\/p>\nspan.set_attributes({
\n "error.type": "timeout",
\n "error.retryable": True,
\n "timeout.actual": response_time,
\n "timeout.configured": kwargs.get('timeout', 30.0)
\n })<\/p>\nspan.record_exception(e)<\/p>\n
# \u8bb0\u5f55\u8d85\u65f6\u6307\u6807
\n self._record_timeout_metrics(span, response_time,
\n kwargs.get('timeout', 30.0))<\/p>\nraise<\/p>\n
except Exception as e:
\n # \u5904\u7406\u5176\u4ed6\u9519\u8bef
\n span.set_status(Status(StatusCode.ERROR, str(e)))
\n span.record_exception(e)
\n raise<\/p>\nreturn wrapper<\/p>\n
def _record_performance_metrics(self, span, response_time: float,
\n timeout_threshold: float):
\n """\u8bb0\u5f55\u6027\u80fd\u6307\u6807"""
\n span.set_attributes({
\n "performance.response_time": response_time,
\n "performance.timeout_ratio": response_time \/ timeout_threshold,
\n "performance.within_timeout": response_time <= timeout_threshold
\n })<\/p>\n# \u6839\u636e\u54cd\u5e94\u65f6\u95f4\u8bbe\u7f6e\u4e25\u91cd\u7a0b\u5ea6
\n if response_time > self.timeout_thresholds['timeout']:
\n span.set_attribute("performance.severity", "timeout")
\n elif response_time > self.timeout_thresholds['warning']:
\n span.set_attribute("performance.severity", "warning")
\n elif response_time > self.timeout_thresholds['critical']:
\n span.set_attribute("performance.severity", "critical")
\n else:
\n span.set_attribute("performance.severity", "normal")<\/p>\ndef _record_timeout_metrics(self, span, actual_time: float,
\n configured_timeout: float):
\n """\u8bb0\u5f55\u8d85\u65f6\u6307\u6807"""
\n timeout_exceeded_by = actual_time – configured_timeout<\/p>\nspan.set_attributes({
\n "timeout.exceeded_by": timeout_exceeded_by,
\n "timeout.percentage_exceeded": (timeout_exceeded_by \/ configured_timeout) * 100,
\n "timeout.suggestion": self._generate_timeout_suggestion(
\n actual_time, configured_timeout
\n )
\n })<\/p>\ndef _generate_timeout_suggestion(self, actual_time: float,
\n configured_timeout: float) -> str:
\n """\u751f\u6210\u8d85\u65f6\u914d\u7f6e\u5efa\u8bae"""
\n if actual_time <= configured_timeout:
\n return "Timeout configuration is appropriate"<\/p>\nexceed_ratio = actual_time \/ configured_timeout<\/p>\n
if exceed_ratio < 1.1:
\n return "Consider increasing timeout by 10%"
\n elif exceed_ratio < 1.5:
\n return "Consider increasing timeout by 50%"
\n elif exceed_ratio < 2.0:
\n return "Consider increasing timeout by 100%"
\n else:
\n return "Investigate upstream service performance or adjust timeout significantly"<\/p>\ndef analyze_timeout_patterns(self, traces: List[Dict]) -> Dict:
\n """\u5206\u6790\u8d85\u65f6\u6a21\u5f0f"""
\n analysis = {
\n 'total_requests': 0,
\n 'timeout_requests': 0,
\n 'timeout_rate': 0.0,
\n 'avg_response_time': 0.0,
\n 'p95_response_time': 0.0,
\n 'timeout_causes': {},
\n 'recommendations': []
\n }<\/p>\nresponse_times = []<\/p>\n
for trace in traces:
\n analysis['total_requests'] += 1<\/p>\nif trace.get('status') == 'timeout':
\n analysis['timeout_requests'] += 1<\/p>\n# \u5206\u6790\u8d85\u65f6\u539f\u56e0
\n cause = self._determine_timeout_cause(trace)
\n analysis['timeout_causes'][cause] = \\\\
\n analysis['timeout_causes'].get(cause, 0) + 1<\/p>\nif 'response_time' in trace:
\n response_times.append(trace['response_time'])<\/p>\n# \u8ba1\u7b97\u7edf\u8ba1\u6307\u6807
\n if response_times:
\n analysis['avg_response_time'] = statistics.mean(response_times)
\n if len(response_times) >= 5:
\n analysis['p95_response_time'] = np.percentile(response_times, 95)<\/p>\nif analysis['total_requests'] > 0:
\n analysis['timeout_rate'] = \\\\
\n analysis['timeout_requests'] \/ analysis['total_requests']<\/p>\n# \u751f\u6210\u5efa\u8bae
\n analysis['recommendations'] = self._generate_recommendations(analysis)<\/p>\nreturn analysis<\/p>\n
def _determine_timeout_cause(self, trace: Dict) -> str:
\n """\u786e\u5b9a\u8d85\u65f6\u539f\u56e0"""
\n # \u57fa\u4e8e\u8ffd\u8e2a\u6570\u636e\u5224\u65ad\u8d85\u65f6\u539f\u56e0
\n spans = trace.get('spans', [])<\/p>\n# \u68c0\u67e5\u7f51\u7edc\u5ef6\u8fdf
\n if any(span.get('type') == 'network' for span in spans):
\n return 'network_latency'<\/p>\n# \u68c0\u67e5\u6570\u636e\u5e93\u67e5\u8be2
\n if any(span.get('type') == 'database' for span in spans):
\n return 'database_query'<\/p>\n# \u68c0\u67e5\u5916\u90e8API\u8c03\u7528
\n if any(span.get('type') == 'external_api' for span in spans):
\n return 'external_service'<\/p>\n# \u68c0\u67e5\u4e1a\u52a1\u903b\u8f91
\n if any(span.get('type') == 'business_logic' for span in spans):
\n return 'business_logic'<\/p>\nreturn 'unknown'<\/p>\n
28.5 \u5ba2\u6237\u7aef\u5904\u7406\u4e0e\u7528\u6237\u4f53\u9a8c\u4f18\u5316<\/h4>\n
28.5.1 \u667a\u80fd\u5ba2\u6237\u7aef\u91cd\u8bd5\u7b56\u7565<\/h5>\n
javascript<\/p>\n
\/\/ \u667a\u80fd504\u5904\u7406\u5ba2\u6237\u7aef
\nclass Smart504Handler {
\n constructor(options = {}) {
\n this.options = {
\n maxRetries: 3,
\n baseDelay: 1000,
\n maxDelay: 30000,
\n jitter: 0.3,
\n timeoutMultiplier: 1.5,
\n circuitBreaker: {
\n failureThreshold: 5,
\n resetTimeout: 60000
\n },
\n …options
\n };<\/p>\nthis.serviceStats = new Map();
\n this.circuitBreakers = new Map();
\n }<\/p>\nasync executeWithRetry(requestFn, context = {}) {
\n const requestId = this._generateId();
\n const serviceName = context.serviceName || 'default';<\/p>\nlet lastError;
\n let attempt = 0;<\/p>\n\/\/ \u83b7\u53d6\u6216\u521b\u5efa\u65ad\u8def\u5668
\n let circuitBreaker = this.circuitBreakers.get(serviceName);
\n if (!circuitBreaker) {
\n circuitBreaker = new CircuitBreaker(this.options.circuitBreaker);
\n this.circuitBreakers.set(serviceName, circuitBreaker);
\n }<\/p>\n\/\/ \u68c0\u67e5\u65ad\u8def\u5668\u72b6\u6001
\n if (circuitBreaker.state === 'OPEN') {
\n throw new CircuitBreakerOpenError(
\n `Circuit breaker open for ${serviceName}`,
\n circuitBreaker.lastFailureTime
\n );
\n }<\/p>\nwhile (attempt <= this.options.maxRetries) {
\n attempt++;<\/p>\nif (attempt > 1) {
\n \/\/ \u8ba1\u7b97\u9000\u907f\u5ef6\u8fdf
\n const delay = this._calculateBackoff(
\n attempt,
\n lastError,
\n context
\n );<\/p>\nawait this._sleep(delay);<\/p>\n
\/\/ \u66f4\u65b0\u4e0a\u4e0b\u6587（\u4f8b\u5982\u6dfb\u52a0\u91cd\u8bd5\u6807\u8bc6）
\n context.retryAttempt = attempt;
\n context.previousErrors = context.previousErrors || [];
\n context.previousErrors.push(lastError);
\n }<\/p>\ntry {
\n \/\/ \u8bbe\u7f6e\u8d85\u65f6
\n const timeout = this._calculateTimeout(context, attempt);<\/p>\n\/\/ \u6267\u884c\u8bf7\u6c42
\n const result = await this._executeWithTimeout(
\n requestFn,
\n timeout,
\n context
\n );<\/p>\n\/\/ \u8bb0\u5f55\u6210\u529f
\n circuitBreaker.recordSuccess();
\n this._recordSuccess(serviceName, context);<\/p>\nreturn result;<\/p>\n
} catch (error) {
\n lastError = error;<\/p>\n\/\/ \u8bb0\u5f55\u5931\u8d25
\n circuitBreaker.recordFailure();
\n this._recordFailure(serviceName, error, context);<\/p>\n\/\/ \u68c0\u67e5\u662f\u5426\u5e94\u8be5\u91cd\u8bd5
\n if (!this._shouldRetry(error, attempt, context)) {
\n break;
\n }<\/p>\n\/\/ \u5982\u679c\u662f504\u9519\u8bef，\u68c0\u67e5\u54cd\u5e94\u5934\u90e8
\n if (error.status === 504) {
\n const retryAfter = error.headers?.get('Retry-After');
\n if (retryAfter) {
\n await this._sleep(parseInt(retryAfter) * 1000);
\n }
\n }
\n }
\n }<\/p>\n\/\/ \u6240\u6709\u91cd\u8bd5\u5931\u8d25
\n throw new MaxRetriesExceededError(
\n `All retries failed for ${serviceName}`,
\n lastError,
\n attempt
\n );
\n }<\/p>\n_calculateBackoff(attempt, lastError, context) {
\n let delay = this.options.baseDelay * Math.pow(2, attempt – 1);<\/p>\n\/\/ \u6dfb\u52a0\u6296\u52a8
\n const jitter = 1 – this.options.jitter + Math.random() * this.options.jitter * 2;
\n delay *= jitter;<\/p>\n\/\/ \u9650\u5236\u6700\u5927\u5ef6\u8fdf
\n delay = Math.min(delay, this.options.maxDelay);<\/p>\n\/\/ \u5bf9\u4e8e504\u9519\u8bef，\u5982\u679c\u670d\u52a1\u5668\u63d0\u4f9b\u4e86Retry-After，\u4f7f\u7528\u5b83
\n if (lastError && lastError.status === 504) {
\n const retryAfter = lastError.headers?.get('Retry-After');
\n if (retryAfter) {
\n const serverDelay = parseInt(retryAfter) * 1000;
\n if (!isNaN(serverDelay)) {
\n delay = Math.max(delay, serverDelay);
\n }
\n }
\n }<\/p>\nreturn Math.round(delay);
\n }<\/p>\n_calculateTimeout(context, attempt) {
\n \/\/ \u57fa\u4e8e\u91cd\u8bd5\u6b21\u6570\u589e\u52a0\u8d85\u65f6\u65f6\u95f4
\n const baseTimeout = context.timeout || 30000;
\n const multiplier = Math.pow(this.options.timeoutMultiplier, attempt – 1);<\/p>\nreturn Math.min(baseTimeout * multiplier, 300000); \/\/ \u6700\u59275\u5206\u949f
\n }<\/p>\n_shouldRetry(error, attempt, context) {
\n if (attempt >= this.options.maxRetries) {
\n return false;
\n }<\/p>\n\/\/ \u91cd\u8bd5504\u9519\u8bef
\n if (error.status === 504) {
\n return true;
\n }<\/p>\n\/\/ \u91cd\u8bd5\u7f51\u7edc\u9519\u8bef
\n if (error.name === 'NetworkError' ||
\n error.name === 'TimeoutError') {
\n return true;
\n }<\/p>\n\/\/ \u4e0d\u91cd\u8bd5\u5ba2\u6237\u7aef\u9519\u8bef（4xx）
\n if (error.status >= 400 && error.status < 500) {
\n return false;
\n }<\/p>\n\/\/ \u9ed8\u8ba4\u91cd\u8bd5\u670d\u52a1\u5668\u9519\u8bef（5xx）
\n return error.status >= 500;
\n }<\/p>\n_executeWithTimeout(requestFn, timeout, context) {
\n return new Promise((resolve, reject) => {
\n const timeoutId = setTimeout(() => {
\n reject(new TimeoutError(`Request timeout after ${timeout}ms`));
\n }, timeout);<\/p>\nrequestFn(context)
\n .then(resolve)
\n .catch(reject)
\n .finally(() => clearTimeout(timeoutId));
\n });
\n }<\/p>\n_recordSuccess(serviceName, context) {
\n const stats = this.serviceStats.get(serviceName) || {
\n successes: 0,
\n failures: 0,
\n totalResponseTime: 0,
\n lastSuccess: Date.now()
\n };<\/p>\nstats.successes++;
\n stats.lastSuccess = Date.now();<\/p>\nif (context.responseTime) {
\n stats.totalResponseTime += context.responseTime;
\n }<\/p>\nthis.serviceStats.set(serviceName, stats);
\n }<\/p>\n_recordFailure(serviceName, error, context) {
\n const stats = this.serviceStats.get(serviceName) || {
\n successes: 0,
\n failures: 0,
\n totalResponseTime: 0,
\n lastFailure: Date.now()
\n };<\/p>\nstats.failures++;
\n stats.lastFailure = Date.now();<\/p>\n\/\/ \u8bb0\u5f55\u9519\u8bef\u7c7b\u578b
\n stats.lastErrorType = error.status || error.name;<\/p>\nthis.serviceStats.set(serviceName, stats);
\n }<\/p>\ngetServiceHealth(serviceName) {
\n const stats = this.serviceStats.get(serviceName);
\n const circuitBreaker = this.circuitBreakers.get(serviceName);<\/p>\nif (!stats) {
\n return { status: 'unknown' };
\n }<\/p>\nconst totalRequests = stats.successes + stats.failures;
\n const successRate = totalRequests > 0 ? stats.successes \/ totalRequests : 0;<\/p>\nconst health = {
\n status: 'healthy',
\n successRate,
\n totalRequests,
\n circuitBreakerState: circuitBreaker?.state || 'unknown',
\n avgResponseTime: stats.successes > 0 ?
\n stats.totalResponseTime \/ stats.successes : 0
\n };<\/p>\n\/\/ \u786e\u5b9a\u5065\u5eb7\u72b6\u6001
\n if (circuitBreaker?.state === 'OPEN') {
\n health.status = 'circuit_open';
\n } else if (successRate < 0.8) {
\n health.status = 'degraded';
\n } else if (successRate < 0.95) {
\n health.status = 'warning';
\n }<\/p>\nreturn health;
\n }
\n}<\/p>\n28.6 \u6700\u4f73\u5b9e\u8df5\u603b\u7ed3<\/h4>\n
28.6.1 \u8d85\u65f6\u914d\u7f6e\u68c0\u67e5\u6e05\u5355<\/h5>\n
Nginx\u914d\u7f6e：<\/p>\n
text<\/p>\n
\u2705 proxy_connect_timeout: 2-5\u79d2
\n\u2705 proxy_send_timeout: 30-60\u79d2（\u6839\u636e\u4e1a\u52a1\u8c03\u6574）
\n\u2705 proxy_read_timeout: 30-60\u79d2（\u6839\u636e\u4e1a\u52a1\u8c03\u6574）
\n\u2705 keepalive_timeout: 15-30\u79d2
\n\u2705 resolver_timeout: 5\u79d2<\/p>\n\u5e94\u7528\u670d\u52a1\u5668\u914d\u7f6e：<\/p>\n
text<\/p>\n
\u2705 \u6570\u636e\u5e93\u8fde\u63a5\u8d85\u65f6：5-10\u79d2
\n\u2705 Redis\u8d85\u65f6：1-2\u79d2
\n\u2705 HTTP\u5ba2\u6237\u7aef\u8d85\u65f6：\u5206\u5c42\u914d\u7f6e
\n\u2705 \u7ebf\u7a0b\u6c60\u7b49\u5f85\u8d85\u65f6：30-60\u79d2<\/p>\n28.6.2 \u76d1\u63a7\u544a\u8b66\u9608\u503c<\/h5>\n
yaml<\/p>\n
# Prometheus\u544a\u8b66\u89c4\u5219
\ngroups:
\n – name: gateway_timeout_alerts
\n rules:
\n – alert: High504ErrorRate
\n expr: |
\n rate(
\n http_requests_total{status="504"}[5m]
\n ) \/ rate(
\n http_requests_total[5m]
\n ) > 0.01
\n for: 2m
\n labels:
\n severity: critical
\n annotations:
\n summary: "High rate of 504 gateway timeout errors"
\n description: |
\n 504\u9519\u8bef\u7387\u8d85\u8fc71%，\u5f53\u524d\u503c: {{ $value | humanizePercentage }}
\n \u53d7\u5f71\u54cd\u7684upstream: {{ $labels.upstream }}<\/p>\n– alert: SlowUpstreamResponse
\n expr: |
\n histogram_quantile(0.95,
\n rate(upstream_response_time_seconds_bucket[5m])
\n ) > 10
\n for: 5m
\n labels:
\n severity: warning
\n annotations:
\n summary: "Slow upstream response times"
\n description: |
\n \u4e0a\u6e38\u670d\u52a195%\u54cd\u5e94\u65f6\u95f4\u8d85\u8fc710\u79d2
\n \u5f53\u524d\u503c: {{ $value }}\u79d2<\/p>\n– alert: UpstreamTimeoutRatioHigh
\n expr: |
\n rate(
\n http_requests_total{status="504"}[5m]
\n ) \/ rate(
\n http_requests_total{status!="504"}[5m]
\n ) > 0.1
\n for: 1m
\n labels:
\n severity: warning
\n annotations:
\n summary: "High ratio of timeout errors"
\n description: |
\n \u8d85\u65f6\u9519\u8bef\u5360\u6bd4\u8d85\u8fc710%，\u53ef\u80fd\u9700\u8981\u8c03\u6574\u8d85\u65f6\u914d\u7f6e<\/p>\n28.6.3 \u5bb9\u91cf\u89c4\u5212\u516c\u5f0f<\/h5>\n
text<\/p>\n
\u8d85\u65f6\u914d\u7f6e = \u57fa\u51c6\u54cd\u5e94\u65f6\u95f4 \u00d7 \u5b89\u5168\u7cfb\u6570 \u00d7 \u4e1a\u52a1\u91cd\u8981\u6027\u7cfb\u6570<\/p>\n
\u5176\u4e2d：
\n– \u57fa\u51c6\u54cd\u5e94\u65f6\u95f4：P99\u54cd\u5e94\u65f6\u95f4
\n– \u5b89\u5168\u7cfb\u6570：1.5-2.0（\u6839\u636e\u670d\u52a1\u7a33\u5b9a\u6027\u8c03\u6574）
\n– \u4e1a\u52a1\u91cd\u8981\u6027\u7cfb\u6570：
\n \u2022 \u5173\u952e\u4e1a\u52a1：1.2
\n \u2022 \u91cd\u8981\u4e1a\u52a1：1.0
\n \u2022 \u975e\u5173\u952e\u4e1a\u52a1：0.8<\/p>\n\u793a\u4f8b：
\n\u8ba2\u5355\u670d\u52a1 P99\u54cd\u5e94\u65f6\u95f4 = 2\u79d2
\n\u5b89\u5168\u7cfb\u6570 = 1.5
\n\u4e1a\u52a1\u91cd\u8981\u6027\u7cfb\u6570 = 1.2<\/p>\n\u8d85\u65f6\u914d\u7f6e = 2 \u00d7 1.5 \u00d7 1.2 = 3.6\u79d2<\/p>\n
\u901a\u8fc7\u5b9e\u65bd\u8fd9\u4e9b\u7b56\u7565，\u53ef\u4ee5\u663e\u8457\u964d\u4f4e504\u9519\u8bef\u7684\u53d1\u751f\u7387，\u63d0\u9ad8\u7cfb\u7edf\u7684\u53ef\u9760\u6027\u548c\u7528\u6237\u4f53\u9a8c\u3002<\/p>\n
\n\u7b2c29\u7ae0：\u5176\u4ed65xx\u72b6\u6001\u7801（505-511）<\/h3>\n
29.1 505 HTTP Version Not Supported<\/h4>\n
29.1.1 \u534f\u8bae\u7248\u672c\u517c\u5bb9\u6027\u7ba1\u7406<\/h5>\n
505 HTTP Version Not Supported\u00a0\u8868\u793a\u670d\u52a1\u5668\u4e0d\u652f\u6301\u8bf7\u6c42\u4e2d\u4f7f\u7528\u7684HTTP\u534f\u8bae\u7248\u672c\u3002<\/p>\n
python<\/p>\n
# HTTP\u7248\u672c\u534f\u5546\u7ba1\u7406\u5668
\nfrom typing import Dict, List, Optional
\nfrom enum import Enum<\/p>\nclass HTTPVersion(Enum):
\n HTTP_0_9 = "HTTP\/0.9"
\n HTTP_1_0 = "HTTP\/1.0"
\n HTTP_1_1 = "HTTP\/1.1"
\n HTTP_2_0 = "HTTP\/2"
\n HTTP_3_0 = "HTTP\/3"<\/p>\nclass HTTPVersionManager:
\n """HTTP\u7248\u672c\u7ba1\u7406\u5668"""<\/p>\ndef __init__(self):
\n # \u652f\u6301\u7684HTTP\u7248\u672c\u53ca\u5176\u529f\u80fd
\n self.supported_versions = {
\n HTTPVersion.HTTP_1_1: {
\n "supported": True,
\n "features": ["keep-alive", "pipelining", "chunked_encoding"],
\n "security_level": "moderate",
\n "performance_score": 7
\n },
\n HTTPVersion.HTTP_2_0: {
\n "supported": True,
\n "features": ["multiplexing", "header_compression", "server_push"],
\n "security_level": "high",
\n "performance_score": 9
\n },
\n HTTPVersion.HTTP_3_0: {
\n "supported": False, # \u5b9e\u9a8c\u6027\u652f\u6301
\n "features": ["QUIC", "improved_security", "better_performance"],
\n "security_level": "very_high",
\n "performance_score": 10,
\n "experimental": True
\n }
\n }<\/p>\n# \u7248\u672c\u5347\u7ea7\u7b56\u7565
\n self.upgrade_policies = {
\n "aggressive": {
\n "force_upgrade": True,
\n "legacy_support_days": 30,
\n "notify_clients": True
\n },
\n "gradual": {
\n "force_upgrade": False,
\n "legacy_support_days": 365,
\n "notify_clients": True
\n },
\n "compatible": {
\n "force_upgrade": False,
\n "legacy_support_days": float('inf'),
\n "notify_clients": False
\n }
\n }<\/p>\nself.current_policy = "gradual"<\/p>\n
def handle_request(self, http_version: str, request_headers: Dict) -> Dict:
\n """\u5904\u7406HTTP\u7248\u672c\u534f\u5546"""
\n requested_version = self._parse_http_version(http_version)<\/p>\n# \u68c0\u67e5\u662f\u5426\u652f\u6301\u8be5\u7248\u672c
\n if requested_version not in self.supported_versions:
\n return self._create_505_response(requested_version)<\/p>\nversion_info = self.supported_versions[requested_version]<\/p>\n
# \u68c0\u67e5\u662f\u5426\u5df2\u5f03\u7528
\n if not version_info["supported"]:
\n # \u6839\u636e\u7b56\u7565\u51b3\u5b9a\u662f\u5426\u8fd4\u56de505
\n if self.upgrade_policies[self.current_policy]["force_upgrade"]:
\n return self._create_505_response(
\n requested_version,
\n suggest_upgrade=True
\n )<\/p>\n# \u68c0\u67e5\u662f\u5426\u9700\u8981\u5347\u7ea7
\n if self._should_suggest_upgrade(requested_version, request_headers):
\n return self._create_upgrade_response(requested_version)<\/p>\n# \u7248\u672c\u652f\u6301，\u6b63\u5e38\u5904\u7406
\n return {"status": "supported", "version": requested_version}<\/p>\ndef _create_505_response(self, requested_version: HTTPVersion,
\n suggest_upgrade: bool = False) -> Dict:
\n """\u521b\u5efa505\u54cd\u5e94"""
\n response = {
\n "status": 505,
\n "headers": {
\n "Content-Type": "application\/json"
\n },
\n "body": {
\n "error": {
\n "code": "http_version_not_supported",
\n "message": f"HTTP version {requested_version.value} is not supported",
\n "supported_versions": [
\n version.value for version, info in self.supported_versions.items()
\n if info["supported"]
\n ]
\n }
\n }
\n }<\/p>\nif suggest_upgrade:
\n latest_version = self._get_latest_supported_version()
\n response["headers"]["Upgrade"] = latest_version.value
\n response["body"]["error"]["suggestion"] = {
\n "upgrade_to": latest_version.value,
\n "benefits": self.supported_versions[latest_version]["features"],
\n "migration_guide": "https:\/\/docs.example.com\/http-upgrade"
\n }<\/p>\nreturn response<\/p>\n
def _create_upgrade_response(self, current_version: HTTPVersion) -> Dict:
\n """\u521b\u5efa\u534f\u8bae\u5347\u7ea7\u54cd\u5e94"""
\n latest_version = self._get_latest_supported_version()<\/p>\nreturn {
\n "status": 426, # Upgrade Required
\n "headers": {
\n "Content-Type": "application\/json",
\n "Upgrade": latest_version.value,
\n "Connection": "Upgrade"
\n },
\n "body": {
\n "info": {
\n "message": "Please upgrade your HTTP protocol",
\n "current_version": current_version.value,
\n "recommended_version": latest_version.value,
\n "improvements": self._compare_versions(current_version, latest_version),
\n "documentation": "https:\/\/docs.example.com\/http-upgrade"
\n }
\n }
\n }<\/p>\ndef _get_latest_supported_version(self) -> HTTPVersion:
\n """\u83b7\u53d6\u6700\u65b0\u652f\u6301\u7684HTTP\u7248\u672c"""
\n supported = [v for v, info in self.supported_versions.items()
\n if info["supported"]]
\n return max(supported, key=lambda x: x.value)<\/p>\ndef _should_suggest_upgrade(self, current_version: HTTPVersion,
\n headers: Dict) -> bool:
\n """\u68c0\u67e5\u662f\u5426\u5e94\u8be5\u5efa\u8bae\u5347\u7ea7"""
\n # \u57fa\u4e8eUser-Agent\u5224\u65ad\u5ba2\u6237\u7aef\u80fd\u529b
\n user_agent = headers.get("User-Agent", "")<\/p>\n# \u73b0\u4ee3\u6d4f\u89c8\u5668\u652f\u6301HTTP\/2\u548cHTTP\/3
\n modern_browsers = ["Chrome\/", "Firefox\/", "Safari\/", "Edge\/"]<\/p>\nif any(browser in user_agent for browser in modern_browsers):
\n # \u73b0\u4ee3\u6d4f\u89c8\u5668，\u53ef\u4ee5\u5efa\u8bae\u5347\u7ea7\u5230HTTP\/2\u6216HTTP\/3
\n return current_version.value in ["HTTP\/1.0", "HTTP\/1.1"]<\/p>\n# API\u5ba2\u6237\u7aef
\n if "python-requests" in user_agent or "curl" in user_agent:
\n # \u8fd9\u4e9b\u5ba2\u6237\u7aef\u901a\u5e38\u652f\u6301HTTP\/2
\n return current_version == HTTPVersion.HTTP_1_1<\/p>\nreturn False<\/p>\n
29.1.2 Nginx\u914d\u7f6e\u793a\u4f8b<\/h5>\n
nginx<\/p>\n
# Nginx HTTP\u7248\u672c\u914d\u7f6e
\nhttp {
\n # \u652f\u6301\u7684HTTP\u7248\u672c
\n http2 on; # \u542f\u7528HTTP\/2<\/p>\n# \u5b9e\u9a8c\u6027HTTP\/3\u652f\u6301
\n # listen 443 quic reuseport;
\n # listen [::]:443 quic reuseport;<\/p>\nserver {
\n listen 80;
\n listen 443 ssl http2; # \u540c\u65f6\u652f\u6301HTTP\/1.1\u548cHTTP\/2<\/p>\nssl_certificate \/etc\/nginx\/ssl\/cert.pem;
\n ssl_certificate_key \/etc\/nginx\/ssl\/key.pem;<\/p>\n# HTTP\/2\u8bbe\u7f6e
\n http2_push_preload on;
\n http2_max_concurrent_streams 128;<\/p>\n# \u5904\u7406\u4e0d\u652f\u6301\u7684HTTP\u7248\u672c
\n error_page 505 = @http_version_error;<\/p>\nlocation @http_version_error {
\n default_type application\/json;<\/p>\n# \u8fd4\u56de\u8be6\u7ec6\u7684\u9519\u8bef\u4fe1\u606f
\n return 505 '{
\n "error": {
\n "code": "unsupported_http_version",
\n "message": "The HTTP protocol version used in the request is not supported",
\n "supported_versions": ["HTTP\/1.1", "HTTP\/2"],
\n "documentation": "https:\/\/developer.example.com\/api\/http-versions"
\n }
\n }';
\n }<\/p>\n# \u5f3a\u5236HTTPS\u548cHTTP\/2\u5347\u7ea7
\n if ($server_protocol !~* "HTTP\/2") {
\n add_header X-HTTP-Version-Upgrade "Consider upgrading to HTTP\/2";
\n add_header Alt-Svc 'h3=":443"; ma=86400'; # \u5e7f\u544aHTTP\/3\u652f\u6301
\n }
\n }
\n}<\/p>\n29.2 506 Variant Also Negotiates<\/h4>\n
506 Variant Also Negotiates\u00a0\u662f\u4e00\u4e2a\u8f83\u5c11\u4f7f\u7528\u7684\u72b6\u6001\u7801，\u8868\u793a\u670d\u52a1\u5668\u5b58\u5728\u5185\u90e8\u914d\u7f6e\u9519\u8bef，\u5bfc\u81f4\u900f\u660e\u5185\u5bb9\u534f\u5546\u51fa\u73b0\u5faa\u73af\u3002<\/p>\n
29.2.1 \u5185\u5bb9\u534f\u5546\u5faa\u73af\u68c0\u6d4b<\/h5>\n
python<\/p>\n
# \u5185\u5bb9\u534f\u5546\u5faa\u73af\u68c0\u6d4b\u5668
\nclass ContentNegotiationManager:
\n """\u5185\u5bb9\u534f\u5546\u7ba1\u7406\u5668，\u9632\u6b62506\u9519\u8bef"""<\/p>\ndef __init__(self):
\n self.negotiation_history = {}
\n self.max_negotiation_depth = 3<\/p>\n# \u652f\u6301\u7684\u5185\u5bb9\u7c7b\u578b
\n self.supported_content_types = {
\n 'application\/json': {
\n 'quality': 1.0,
\n 'charset': ['utf-8'],
\n 'language': ['en', 'zh']
\n },
\n 'application\/xml': {
\n 'quality': 0.9,
\n 'charset': ['utf-8'],
\n 'language': ['en']
\n },
\n 'text\/html': {
\n 'quality': 0.8,
\n 'charset': ['utf-8', 'iso-8859-1'],
\n 'language': ['en', 'zh', 'ja']
\n }
\n }<\/p>\ndef negotiate_content(self, request_headers: Dict,
\n available_variants: List[Dict]) -> Dict:
\n """\u6267\u884c\u5185\u5bb9\u534f\u5546，\u9632\u6b62\u5faa\u73af"""
\n request_id = request_headers.get('X-Request-ID')<\/p>\nif request_id:
\n # \u68c0\u67e5\u534f\u5546\u5386\u53f2
\n history = self.negotiation_history.get(request_id, [])<\/p>\nif len(history) >= self.max_negotiation_depth:
\n # \u68c0\u6d4b\u5230\u53ef\u80fd\u7684\u534f\u5546\u5faa\u73af
\n return self._create_506_response(history)<\/p>\n# \u8bb0\u5f55\u672c\u6b21\u534f\u5546
\n history.append({
\n 'timestamp': time.time(),
\n 'accept_header': request_headers.get('Accept'),
\n 'available_variants': available_variants
\n })
\n self.negotiation_history[request_id] = history<\/p>\n# \u6267\u884c\u5185\u5bb9\u534f\u5546
\n selected_variant = self._select_best_variant(
\n request_headers,
\n available_variants
\n )<\/p>\nif not selected_variant:
\n # \u6ca1\u6709\u53ef\u63a5\u53d7\u7684\u53d8\u4f53
\n return self._create_406_response(available_variants)<\/p>\nreturn {
\n 'status': 'success',
\n 'selected_variant': selected_variant,
\n 'vary_header': self._generate_vary_header(request_headers)
\n }<\/p>\ndef _select_best_variant(self, headers: Dict,
\n variants: List[Dict]) -> Optional[Dict]:
\n """\u9009\u62e9\u6700\u4f73\u53d8\u4f53"""
\n accept_header = headers.get('Accept', '*\/*')
\n accept_language = headers.get('Accept-Language', 'en')
\n accept_charset = headers.get('Accept-Charset', 'utf-8')<\/p>\n# \u89e3\u6790Accept\u5934\u90e8
\n accepted_types = self._parse_accept_header(accept_header)<\/p>\n# \u4e3a\u6bcf\u4e2a\u53d8\u4f53\u8bc4\u5206
\n scored_variants = []<\/p>\nfor variant in variants:
\n score = self._calculate_variant_score(
\n variant,
\n accepted_types,
\n accept_language,
\n accept_charset
\n )<\/p>\nif score > 0:
\n scored_variants.append((score, variant))<\/p>\nif not scored_variants:
\n return None<\/p>\n# \u9009\u62e9\u6700\u9ad8\u5206\u7684\u53d8\u4f53
\n scored_variants.sort(reverse=True)
\n return scored_variants[0][1]<\/p>\ndef _create_506_response(self, negotiation_history: List) -> Dict:
\n """\u521b\u5efa506\u54cd\u5e94"""
\n return {
\n 'status': 506,
\n 'headers': {
\n 'Content-Type': 'application\/json',
\n 'Vary': 'Accept, Accept-Language, Accept-Charset'
\n },
\n 'body': {
\n 'error': {
\n 'code': 'variant_also_negotiates',
\n 'message': 'Content negotiation resulted in a circular reference',
\n 'details': {
\n 'negotiation_depth': len(negotiation_history),
\n 'negotiation_history': negotiation_history,
\n 'max_allowed_depth': self.max_negotiation_depth
\n },
\n 'suggestions': [
\n 'Check server content negotiation configuration',
\n 'Ensure variants have unique content types',
\n 'Review Accept headers in client requests'
\n ]
\n }
\n }
\n }<\/p>\ndef _create_406_response(self, available_variants: List[Dict]) -> Dict:
\n """\u521b\u5efa406 Not Acceptable\u54cd\u5e94"""
\n return {
\n 'status': 406,
\n 'headers': {
\n 'Content-Type': 'application\/json',
\n 'Vary': 'Accept, Accept-Language, Accept-Charset'
\n },
\n 'body': {
\n 'error': {
\n 'code': 'not_acceptable',
\n 'message': 'No acceptable variant found',
\n 'available_variants': available_variants,
\n 'supported_content_types': list(self.supported_content_types.keys())
\n }
\n }
\n }<\/p>\n29.3 507 Insufficient Storage<\/h4>\n
507 Insufficient Storage\u00a0\u8868\u793a\u670d\u52a1\u5668\u65e0\u6cd5\u5b58\u50a8\u5b8c\u6210\u8bf7\u6c42\u6240\u9700\u7684\u5185\u5bb9，\u901a\u5e38\u4e0eWebDAV\u534f\u8bae\u76f8\u5173\u3002<\/p>\n
29.3.1 \u5b58\u50a8\u914d\u989d\u7ba1\u7406\u7cfb\u7edf<\/h5>\n
python<\/p>\n
# \u5b58\u50a8\u914d\u989d\u7ba1\u7406\u5668
\nclass StorageQuotaManager:
\n """\u5b58\u50a8\u914d\u989d\u7ba1\u7406\u5668，\u9632\u6b62507\u9519\u8bef"""<\/p>\ndef __init__(self):
\n self.user_quotas = {}
\n self.default_quota = {
\n 'total': 100 * 1024 * 1024, # 100MB
\n 'file_count': 1000,
\n 'max_file_size': 10 * 1024 * 1024 # 10MB
\n }<\/p>\n# \u5b58\u50a8\u4f7f\u7528\u60c5\u51b5\u7f13\u5b58
\n self.usage_cache = {}
\n self.cache_ttl = 300 # 5\u5206\u949f<\/p>\nasync def check_quota(self, user_id: str,
\n operation: str,
\n size: int = 0) -> Dict:
\n """\u68c0\u67e5\u5b58\u50a8\u914d\u989d"""<\/p>\n# \u83b7\u53d6\u7528\u6237\u914d\u989d
\n quota = self._get_user_quota(user_id)<\/p>\n# \u83b7\u53d6\u5f53\u524d\u4f7f\u7528\u60c5\u51b5
\n usage = await self._get_storage_usage(user_id)<\/p>\n# \u68c0\u67e5\u64cd\u4f5c\u662f\u5426\u5141\u8bb8
\n check_result = self._check_operation(operation, size, quota, usage)<\/p>\nif not check_result['allowed']:
\n return self._create_507_response(user_id, quota, usage, check_result)<\/p>\nreturn {'allowed': True, 'quota': quota, 'usage': usage}<\/p>\n
def _check_operation(self, operation: str, size: int,
\n quota: Dict, usage: Dict) -> Dict:
\n """\u68c0\u67e5\u7279\u5b9a\u64cd\u4f5c"""
\n result = {
\n 'allowed': True,
\n 'reasons': []
\n }<\/p>\nif operation == 'upload':
\n # \u68c0\u67e5\u6587\u4ef6\u5927\u5c0f\u9650\u5236
\n if size > quota['max_file_size']:
\n result['allowed'] = False
\n result['reasons'].append(
\n f"File size ({size} bytes) exceeds maximum allowed "
\n f"({quota['max_file_size']} bytes)"
\n )<\/p>\n# \u68c0\u67e5\u603b\u5b58\u50a8\u7a7a\u95f4
\n projected_total = usage['total_bytes'] + size
\n if projected_total > quota['total']:
\n result['allowed'] = False
\n result['reasons'].append(
\n f"Projected storage ({projected_total} bytes) exceeds "
\n f"quota ({quota['total']} bytes)"
\n )<\/p>\n# \u68c0\u67e5\u6587\u4ef6\u6570\u91cf\u9650\u5236
\n if usage['file_count'] >= quota['file_count']:
\n result['allowed'] = False
\n result['reasons'].append(
\n f"File count ({usage['file_count']}) exceeds limit "
\n f"({quota['file_count']})"
\n )<\/p>\nelif operation == 'update':
\n # \u66f4\u65b0\u73b0\u6709\u6587\u4ef6
\n # \u8fd9\u91cc\u53ef\u4ee5\u6839\u636e\u9700\u8981\u6dfb\u52a0\u7279\u5b9a\u68c0\u67e5
\n pass<\/p>\nreturn result<\/p>\n
def _create_507_response(self, user_id: str, quota: Dict,
\n usage: Dict, check_result: Dict) -> Dict:
\n """\u521b\u5efa507\u54cd\u5e94"""
\n return {
\n 'status': 507,
\n 'headers': {
\n 'Content-Type': 'application\/json',
\n 'X-Storage-Quota-Total': str(quota['total']),
\n 'X-Storage-Quota-Used': str(usage['total_bytes']),
\n 'X-Storage-Quota-Remaining': str(quota['total'] – usage['total_bytes'])
\n },
\n 'body': {
\n 'error': {
\n 'code': 'insufficient_storage',
\n 'message': 'Insufficient storage to complete the operation',
\n 'details': {
\n 'user_id': user_id,
\n 'operation': check_result.get('operation'),
\n 'reasons': check_result['reasons'],
\n 'quota': {
\n 'total_bytes': quota['total'],
\n 'max_file_size': quota['max_file_size'],
\n 'max_file_count': quota['file_count']
\n },
\n 'usage': {
\n 'total_bytes': usage['total_bytes'],
\n 'file_count': usage['file_count'],
\n 'percentage_used':
\n (usage['total_bytes'] \/ quota['total']) * 100
\n },
\n 'suggestions': [
\n 'Delete unused files to free up space',
\n 'Consider upgrading your storage plan',
\n 'Compress files before uploading'
\n ],
\n 'upgrade_url': f'https:\/\/example.com\/upgrade\/{user_id}'
\n }
\n }
\n }
\n }<\/p>\nasync def _get_storage_usage(self, user_id: str) -> Dict:
\n """\u83b7\u53d6\u5b58\u50a8\u4f7f\u7528\u60c5\u51b5"""
\n # \u68c0\u67e5\u7f13\u5b58
\n cache_key = f'usage:{user_id}'
\n if cache_key in self.usage_cache:
\n cached = self.usage_cache[cache_key]
\n if time.time() – cached['timestamp'] < self.cache_ttl:
\n return cached['usage']<\/p>\n# \u4ece\u6570\u636e\u5e93\u83b7\u53d6\u4f7f\u7528\u60c5\u51b5
\n usage = await self._query_storage_usage(user_id)<\/p>\n# \u66f4\u65b0\u7f13\u5b58
\n self.usage_cache[cache_key] = {
\n 'timestamp': time.time(),
\n 'usage': usage
\n }<\/p>\nreturn usage<\/p>\n
29.4 508 Loop Detected<\/h4>\n
508 Loop Detected\u00a0(WebDAV\u6269\u5c55) \u8868\u793a\u670d\u52a1\u5668\u5728\u5904\u7406\u8bf7\u6c42\u65f6\u68c0\u6d4b\u5230\u65e0\u9650\u5faa\u73af\u3002<\/p>\n
29.4.1 \u5faa\u73af\u68c0\u6d4b\u4e0e\u9632\u62a4<\/h5>\n
python<\/p>\n
# \u8bf7\u6c42\u5faa\u73af\u68c0\u6d4b\u5668
\nclass LoopDetector:
\n """\u68c0\u6d4b\u548c\u9632\u6b62\u65e0\u9650\u5faa\u73af"""<\/p>\ndef __init__(self, max_depth: int = 10, max_iterations: int = 100):
\n self.max_depth = max_depth
\n self.max_iterations = max_iterations
\n self.active_requests = {}<\/p>\n# \u5faa\u73af\u68c0\u6d4b\u6a21\u5f0f
\n self.detection_modes = {
\n 'strict': {
\n 'check_headers': True,
\n 'check_params': True,
\n 'check_body': False,
\n 'threshold': 3
\n },
\n 'moderate': {
\n 'check_headers': True,
\n 'check_params': True,
\n 'check_body': False,
\n 'threshold': 5
\n },
\n 'lenient': {
\n 'check_headers': False,
\n 'check_params': True,
\n 'check_body': False,
\n 'threshold': 10
\n }
\n }<\/p>\nself.current_mode = 'moderate'<\/p>\n
def track_request(self, request_id: str, request_data: Dict) -> bool:
\n """\u8ffd\u8e2a\u8bf7\u6c42，\u68c0\u6d4b\u5faa\u73af"""
\n if request_id not in self.active_requests:
\n self.active_requests[request_id] = {
\n 'count': 1,
\n 'first_seen': time.time(),
\n 'last_seen': time.time(),
\n 'variants': [self._create_request_signature(request_data)]
\n }
\n return True<\/p>\nrecord = self.active_requests[request_id]
\n record['count'] += 1
\n record['last_seen'] = time.time()<\/p>\n# \u68c0\u67e5\u8bf7\u6c42\u8ba1\u6570
\n if record['count'] > self.max_iterations:
\n return False<\/p>\n# \u68c0\u67e5\u65f6\u95f4\u7a97\u53e3
\n time_window = record['last_seen'] – record['first_seen']
\n requests_per_second = record['count'] \/ max(time_window, 1)<\/p>\nif requests_per_second > 10: # \u6bcf\u79d210\u4e2a\u8bf7\u6c42
\n return False<\/p>\n# \u68c0\u67e5\u8bf7\u6c42\u53d8\u4f53（\u68c0\u6d4b\u5faa\u73af\u4e2d\u7684\u53d8\u5316）
\n current_signature = self._create_request_signature(request_data)<\/p>\nif current_signature in record['variants']:
\n # \u68c0\u6d4b\u5230\u76f8\u540c\u7684\u8bf7\u6c42\u53d8\u4f53
\n variant_index = record['variants'].index(current_signature)
\n loop_size = len(record['variants']) – variant_index<\/p>\nif loop_size <= self.detection_modes[self.current_mode]['threshold']:
\n # \u68c0\u6d4b\u5230\u5c0f\u5faa\u73af
\n return False
\n else:
\n record['variants'].append(current_signature)<\/p>\n# \u68c0\u67e5\u53d8\u4f53\u6570\u91cf
\n if len(record['variants']) > self.max_depth:
\n return False<\/p>\nreturn True<\/p>\n
def _create_request_signature(self, request_data: Dict) -> str:
\n """\u521b\u5efa\u8bf7\u6c42\u7b7e\u540d"""
\n mode = self.detection_modes[self.current_mode]<\/p>\nsignature_parts = []<\/p>\n
if mode['check_headers']:
\n headers = request_data.get('headers', {})
\n # \u9009\u62e9\u5173\u952e\u5934\u90e8
\n key_headers = {k: v for k, v in headers.items()
\n if k.lower() in ['authorization', 'content-type', 'user-agent']}
\n signature_parts.append(f"headers:{hash(str(sorted(key_headers.items())))}")<\/p>\nif mode['check_params']:
\n params = request_data.get('params', {})
\n signature_parts.append(f"params:{hash(str(sorted(params.items())))}")<\/p>\nif mode['check_body'] and 'body' in request_data:
\n body = request_data['body']
\n # \u5bf9\u4e8e\u5927\u8bf7\u6c42\u4f53，\u53ea\u4f7f\u7528\u54c8\u5e0c
\n if isinstance(body, str) and len(body) > 1000:
\n signature_parts.append(f"body_hash:{hash(body)}")
\n else:
\n signature_parts.append(f"body:{hash(str(body))}")<\/p>\nreturn '|'.join(signature_parts)<\/p>\n
def create_508_response(self, request_id: str,
\n request_data: Dict) -> Dict:
\n """\u521b\u5efa508\u54cd\u5e94"""
\n record = self.active_requests.get(request_id, {})<\/p>\nreturn {
\n 'status': 508,
\n 'headers': {
\n 'Content-Type': 'application\/json',
\n 'X-Loop-Detected': 'true',
\n 'X-Max-Iterations': str(self.max_iterations)
\n },
\n 'body': {
\n 'error': {
\n 'code': 'loop_detected',
\n 'message': 'Infinite loop detected while processing the request',
\n 'details': {
\n 'request_id': request_id,
\n 'iterations': record.get('count', 0),
\n 'time_window': record.get('last_seen', 0) – record.get('first_seen', 0),
\n 'variants_detected': len(record.get('variants', [])),
\n 'detection_mode': self.current_mode,
\n 'request_signature': self._create_request_signature(request_data)
\n },
\n 'suggestions': [
\n 'Check for recursive function calls',
\n 'Verify loop termination conditions',
\n 'Review request parameters for circular references',
\n 'Implement proper caching to avoid redundant processing'
\n ]
\n }
\n }
\n }<\/p>\ndef cleanup_old_requests(self, max_age: int = 3600):
\n """\u6e05\u7406\u65e7\u7684\u8bf7\u6c42\u8bb0\u5f55"""
\n current_time = time.time()
\n to_remove = []<\/p>\nfor request_id, record in self.active_requests.items():
\n if current_time – record['last_seen'] > max_age:
\n to_remove.append(request_id)<\/p>\nfor request_id in to_remove:
\n del self.active_requests[request_id]<\/p>\n29.5 510 Not Extended<\/h4>\n
510 Not Extended\u00a0\u8868\u793a\u8bf7\u6c42\u9700\u8981\u8fdb\u4e00\u6b65\u6269\u5c55\u624d\u80fd\u88ab\u670d\u52a1\u5668\u5904\u7406\u3002<\/p>\n
29.5.1 \u6269\u5c55\u9700\u6c42\u534f\u5546<\/h5>\n
python<\/p>\n
# \u6269\u5c55\u9700\u6c42\u534f\u5546\u7ba1\u7406\u5668
\nclass ExtensionNegotiator:
\n """\u5904\u7406510 Not Extended\u54cd\u5e94"""<\/p>\ndef __init__(self):
\n self.required_extensions = {
\n 'security': {
\n 'require_2fa': {
\n 'description': 'Two-factor authentication required',
\n 'priority': 'high',
\n 'implementation': 'https:\/\/docs.example.com\/2fa'
\n },
\n 'require_ssl': {
\n 'description': 'SSL\/TLS encryption required',
\n 'priority': 'critical',
\n 'implementation': 'https:\/\/docs.example.com\/ssl-setup'
\n }
\n },
\n 'compliance': {
\n 'require_gdpr_consent': {
\n 'description': 'GDPR consent required for EU users',
\n 'priority': 'medium',
\n 'implementation': 'https:\/\/docs.example.com\/gdpr-compliance'
\n }
\n },
\n 'features': {
\n 'require_api_key': {
\n 'description': 'API key authentication required',
\n 'priority': 'high',
\n 'implementation': 'https:\/\/docs.example.com\/api-authentication'
\n }
\n }
\n }<\/p>\ndef check_requirements(self, request: Dict,
\n user_context: Dict) -> List[Dict]:
\n """\u68c0\u67e5\u8bf7\u6c42\u662f\u5426\u6ee1\u8db3\u6240\u6709\u8981\u6c42"""
\n missing_extensions = []<\/p>\n# \u68c0\u67e5\u5b89\u5168\u6269\u5c55
\n if not self._check_security_extensions(request, user_context):
\n missing_extensions.extend(
\n self._get_missing_security_extensions(user_context)
\n )<\/p>\n# \u68c0\u67e5\u5408\u89c4\u6269\u5c55
\n if not self._check_compliance_extensions(request, user_context):
\n missing_extensions.extend(
\n self._get_missing_compliance_extensions(user_context)
\n )<\/p>\n# \u68c0\u67e5\u529f\u80fd\u6269\u5c55
\n if not self._check_feature_extensions(request, user_context):
\n missing_extensions.extend(
\n self._get_missing_feature_extensions(user_context)
\n )<\/p>\nreturn missing_extensions<\/p>\n
def create_510_response(self, missing_extensions: List[Dict],
\n request: Dict) -> Dict:
\n """\u521b\u5efa510\u54cd\u5e94"""
\n return {
\n 'status': 510,
\n 'headers': {
\n 'Content-Type': 'application\/json',
\n 'X-Required-Extensions': ','.join(
\n [ext['code'] for ext in missing_extensions]
\n )
\n },
\n 'body': {
\n 'error': {
\n 'code': 'not_extended',
\n 'message': 'Further extensions are required to process this request',
\n 'details': {
\n 'missing_extensions': missing_extensions,
\n 'request_summary': {
\n 'method': request.get('method'),
\n 'path': request.get('path'),
\n 'user': request.get('user', {}).get('id')
\n },
\n 'next_steps': [
\n 'Implement the required extensions listed below',
\n 'Review the implementation documentation',
\n 'Test with the extension verification endpoint'
\n ],
\n 'verification_endpoint': '\/api\/v1\/extensions\/verify',
\n 'documentation': 'https:\/\/docs.example.com\/extensions'
\n }
\n }
\n }
\n }<\/p>\ndef _check_security_extensions(self, request: Dict,
\n user_context: Dict) -> bool:
\n """\u68c0\u67e5\u5b89\u5168\u6269\u5c55"""
\n # \u68c0\u67e5SSL
\n if request.get('protocol') != 'https':
\n return False<\/p>\n# \u68c0\u67e52FA（\u5bf9\u4e8e\u654f\u611f\u64cd\u4f5c）
\n if self._is_sensitive_operation(request):
\n if not user_context.get('two_factor_enabled', False):
\n return False<\/p>\nreturn True<\/p>\n
def _get_missing_security_extensions(self, user_context: Dict) -> List[Dict]:
\n """\u83b7\u53d6\u7f3a\u5c11\u7684\u5b89\u5168\u6269\u5c55"""
\n missing = []<\/p>\n# \u68c0\u67e52FA
\n if not user_context.get('two_factor_enabled', False):
\n missing.append({
\n 'category': 'security',
\n 'code': 'require_2fa',
\n **self.required_extensions['security']['require_2fa']
\n })<\/p>\nreturn missing<\/p>\n
29.6 511 Network Authentication Required<\/h4>\n
511 Network Authentication Required\u00a0\u8868\u793a\u5ba2\u6237\u7aef\u9700\u8981\u8fdb\u884c\u7f51\u7edc\u8ba4\u8bc1\u624d\u80fd\u8bbf\u95ee\u8d44\u6e90\u3002<\/p>\n
29.6.1 \u7f51\u7edc\u8ba4\u8bc1\u95e8\u6237\u5b9e\u73b0<\/h5>\n
python<\/p>\n
# \u7f51\u7edc\u8ba4\u8bc1\u95e8\u6237\u7ba1\u7406\u5668
\nclass NetworkAuthPortal:
\n """\u7ba1\u7406511\u7f51\u7edc\u8ba4\u8bc1"""<\/p>\ndef __init__(self):
\n self.captive_portal_url = "https:\/\/portal.example.com\/auth"
\n self.auth_sessions = {}
\n self.session_timeout = 3600 # 1\u5c0f\u65f6<\/p>\n# \u8ba4\u8bc1\u65b9\u6cd5
\n self.auth_methods = {
\n 'social': {
\n 'google': {
\n 'name': 'Google',
\n 'url': '\/auth\/google',
\n 'icon': 'google.svg'
\n },
\n 'facebook': {
\n 'name': 'Facebook',
\n 'url': '\/auth\/facebook',
\n 'icon': 'facebook.svg'
\n }
\n },
\n 'enterprise': {
\n 'sso': {
\n 'name': 'Single Sign-On',
\n 'url': '\/auth\/sso',
\n 'icon': 'sso.svg'
\n },
\n 'ldap': {
\n 'name': 'LDAP\/Active Directory',
\n 'url': '\/auth\/ldap',
\n 'icon': 'ldap.svg'
\n }
\n },
\n 'simple': {
\n 'email': {
\n 'name': 'Email',
\n 'url': '\/auth\/email',
\n 'icon': 'email.svg'
\n },
\n 'sms': {
\n 'name': 'SMS',
\n 'url': '\/auth\/sms',
\n 'icon': 'sms.svg'
\n }
\n }
\n }<\/p>\ndef create_511_response(self, request: Dict,
\n network_info: Dict) -> Dict:
\n """\u521b\u5efa511\u54cd\u5e94"""
\n session_id = self._create_auth_session(request, network_info)<\/p>\n# \u6839\u636e\u8bbe\u5907\u7c7b\u578b\u9009\u62e9\u8ba4\u8bc1\u65b9\u6cd5
\n user_agent = request.headers.get('User-Agent', '')
\n auth_methods = self._select_auth_methods(user_agent)<\/p>\nreturn {
\n 'status': 511,
\n 'headers': {
\n 'Content-Type': 'text\/html', # \u901a\u5e38\u8fd4\u56deHTML\u95e8\u6237\u9875\u9762
\n 'X-Network-Auth-Required': 'true',
\n 'X-Auth-Session': session_id,
\n 'X-Captive-Portal': self.captive_portal_url
\n },
\n 'body': self._generate_portal_html(
\n session_id,
\n network_info,
\n auth_methods
\n )
\n }<\/p>\ndef _generate_portal_html(self, session_id: str,
\n network_info: Dict,
\n auth_methods: List[Dict]) -> str:
\n """\u751f\u6210\u8ba4\u8bc1\u95e8\u6237HTML"""
\n return f"""
\n<!DOCTYPE html>
\n<html lang="en">
\n<head>
\n <meta charset="UTF-8">
\n <meta name="viewport" content="width=device-width, initial-scale=1.0">
\n <title>Network Authentication Required<\/title>
\n <style>
\n body {{
\n font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
\n background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
\n min-height: 100vh;
\n display: flex;
\n align-items: center;
\n justify-content: center;
\n padding: 20px;
\n }}
\n .portal-container {{
\n background: white;
\n border-radius: 12px;
\n padding: 40px;
\n box-shadow: 0 20px 60px rgba(0,0,0,0.3);
\n max-width: 480px;
\n width: 100%;
\n }}
\n .network-info {{
\n background: #f7fafc;
\n padding: 15px;
\n border-radius: 8px;
\n margin-bottom: 30px;
\n }}
\n .auth-methods {{
\n display: grid;
\n gap: 15px;
\n margin-top: 20px;
\n }}
\n .auth-method {{
\n display: flex;
\n align-items: center;
\n padding: 15px;
\n border: 2px solid #e2e8f0;
\n border-radius: 8px;
\n text-decoration: none;
\n color: #2d3748;
\n transition: all 0.2s;
\n }}
\n .auth-method:hover {{
\n border-color: #667eea;
\n transform: translateY(-2px);
\n }}
\n .auth-method-icon {{
\n width: 24px;
\n height: 24px;
\n margin-right: 15px;
\n }}
\n <\/style>
\n<\/head>
\n<body>
\n <div class="portal-container">
\n <h1>Network Authentication Required<\/h1>
\n <p>You need to authenticate to access this network.<\/p><\/p>\n<div class="network-info">
\n <h3>Network Information<\/h3>
\n <p><strong>SSID:<\/strong> {network_info.get('ssid', 'Unknown')}<\/p>
\n <p><strong>IP Address:<\/strong> {network_info.get('ip', 'Unknown')}<\/p>
\n <p><strong>Location:<\/strong> {network_info.get('location', 'Unknown')}<\/p>
\n <\/div><\/p>\n<h2>Choose Authentication Method<\/h2>
\n <div class="auth-methods">
\n {' '.join([self._generate_auth_method_html(method) for method in auth_methods])}
\n <\/div><\/p>\n<div style="margin-top: 30px; font-size: 0.9em; color: #718096;">
\n <p>By authenticating, you agree to our
\n <a href="\/terms">Terms of Service<\/a> and
\n <a href="\/privacy">Privacy Policy<\/a>.<\/p>
\n <\/div>
\n <\/div>
\n<\/body>
\n<\/html>
\n """<\/p>\ndef _generate_auth_method_html(self, method: Dict) -> str:
\n """\u751f\u6210\u8ba4\u8bc1\u65b9\u6cd5HTML"""
\n return f"""
\n <a href="{method['url']}" class="auth-method">
\n <img src="\/icons\/{method['icon']}" class="auth-method-icon"
\n alt="{method['name']}">
\n <span>Sign in with {method['name']}<\/span>
\n <\/a>
\n """<\/p>\ndef _select_auth_methods(self, user_agent: str) -> List[Dict]:
\n """\u6839\u636e\u7528\u6237\u4ee3\u7406\u9009\u62e9\u8ba4\u8bc1\u65b9\u6cd5"""
\n methods = []<\/p>\n# \u79fb\u52a8\u8bbe\u5907
\n if 'Mobile' in user_agent or 'Android' in user_agent or 'iPhone' in user_agent:
\n methods.append(self.auth_methods['simple']['sms'])
\n methods.append(self.auth_methods['social']['google'])<\/p>\n# \u684c\u9762\u8bbe\u5907
\n else:
\n methods.append(self.auth_methods['social']['google'])
\n methods.append(self.auth_methods['social']['facebook'])
\n methods.append(self.auth_methods['enterprise']['sso'])<\/p>\n# \u603b\u662f\u5305\u542b\u90ae\u7bb1\u8ba4\u8bc1
\n methods.append(self.auth_methods['simple']['email'])<\/p>\nreturn methods<\/p>\n
def _create_auth_session(self, request: Dict,
\n network_info: Dict) -> str:
\n """\u521b\u5efa\u8ba4\u8bc1\u4f1a\u8bdd"""
\n session_id = self._generate_session_id()<\/p>\nself.auth_sessions[session_id] = {
\n 'created_at': time.time(),
\n 'ip_address': request.get('remote_addr'),
\n 'user_agent': request.headers.get('User-Agent'),
\n 'original_url': request.get('original_url'),
\n 'network_info': network_info,
\n 'status': 'pending'
\n }<\/p>\nreturn session_id<\/p>\n
29.7 \u6700\u4f73\u5b9e\u8df5\u603b\u7ed3<\/h4>\n
29.7.1 \u72b6\u6001\u7801\u4f7f\u7528\u6307\u5357<\/h5>\n
\n
\u72b6\u6001\u7801\u540d\u79f0\u4f7f\u7528\u573a\u666f\u6700\u4f73\u5b9e\u8df5<\/tr>\n \n\n 505<\/td>\n HTTP Version Not Supported<\/td>\n \u4e0d\u652f\u6301\u7684HTTP\u534f\u8bae\u7248\u672c<\/td>\n \u63d0\u4f9b\u652f\u6301\u7684\u7248\u672c\u5217\u8868\u548c\u5347\u7ea7\u6307\u5357<\/td>\n<\/tr>\n \n 506<\/td>\n Variant Also Negotiates<\/td>\n \u5185\u5bb9\u534f\u5546\u5faa\u73af<\/td>\n \u5b9e\u73b0\u5faa\u73af\u68c0\u6d4b\u548c\u9650\u5236\u6700\u5927\u6df1\u5ea6<\/td>\n<\/tr>\n \n 507<\/td>\n Insufficient Storage<\/td>\n \u5b58\u50a8\u7a7a\u95f4\u4e0d\u8db3<\/td>\n \u5b9e\u73b0\u914d\u989d\u7ba1\u7406\u548c\u53cb\u597d\u7684\u9519\u8bef\u4fe1\u606f<\/td>\n<\/tr>\n \n 508<\/td>\n Loop Detected<\/td>\n \u68c0\u6d4b\u5230\u65e0\u9650\u5faa\u73af<\/td>\n \u6dfb\u52a0\u5faa\u73af\u68c0\u6d4b\u548c\u9002\u5f53\u7684\u8d85\u65f6<\/td>\n<\/tr>\n \n 510<\/td>\n Not Extended<\/td>\n \u9700\u8981\u989d\u5916\u6269\u5c55<\/td>\n \u660e\u786e\u5217\u51fa\u6240\u9700\u6269\u5c55\u548c\u5b9e\u73b0\u6307\u5357<\/td>\n<\/tr>\n \n 511<\/td>\n Network Authentication Required<\/td>\n \u9700\u8981\u7f51\u7edc\u8ba4\u8bc1<\/td>\n \u63d0\u4f9b\u7528\u6237\u53cb\u597d\u7684\u8ba4\u8bc1\u95e8\u6237<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n 29.7.2 \u76d1\u63a7\u548c\u544a\u8b66\u914d\u7f6e<\/h5>\n
yaml<\/p>\n
# Prometheus\u76d1\u63a7\u914d\u7f6e
\nscrape_configs:
\n – job_name: 'extended_5xx'
\n static_configs:
\n – targets: ['app:9090']<\/p>\n# \u76d1\u63a7\u4e0d\u5e38\u89c1\u76845xx\u9519\u8bef
\n relabel_configs:
\n – source_labels: [__meta_kubernetes_pod_label_app]
\n regex: .*
\n action: keep<\/p>\n# \u544a\u8b66\u89c4\u5219
\ngroups:
\n – name: extended_5xx_alerts
\n rules:
\n – alert: Unusual5xxError
\n expr: |
\n sum by (status) (
\n rate(http_requests_total{status=~"5[0-9]{2}"}[5m])
\n ) > 0
\n for: 1m
\n labels:
\n severity: info
\n annotations:
\n summary: "Unusual 5xx status code detected"
\n description: |
\n \u68c0\u6d4b\u5230\u4e0d\u5e38\u89c1\u76845xx\u72b6\u6001\u7801: {{ $labels.status }}
\n \u8bf7\u6c42\u8def\u5f84: {{ $labels.path }}<\/p>\n– alert: HTTPVersionNotSupported
\n expr: |
\n rate(http_requests_total{status="505"}[5m]) > 0.001
\n for: 2m
\n labels:
\n severity: warning
\n annotations:
\n summary: "HTTP version not supported errors"
\n description: |
\n 505\u9519\u8bef\u7387\u8d85\u8fc70.1%
\n \u53ef\u80fd\u9700\u8981\u66f4\u65b0\u5ba2\u6237\u7aef\u6216\u8c03\u6574\u670d\u52a1\u5668\u914d\u7f6e<\/p>\n\u901a\u8fc7\u6b63\u786e\u5904\u7406\u8fd9\u4e9b\u4e0d\u5e38\u89c1\u76845xx\u72b6\u6001\u7801，\u53ef\u4ee5\u63d0\u4f9b\u66f4\u597d\u7684\u7528\u6237\u4f53\u9a8c，\u540c\u65f6\u5e2e\u52a9\u5f00\u53d1\u8005\u548c\u8fd0\u7ef4\u4eba\u5458\u5feb\u901f\u8bca\u65ad\u548c\u89e3\u51b3\u95ee\u9898\u3002<\/p>\n
\n\u603b\u7ed3：5xx\u72b6\u6001\u7801\u7cfb\u7edf\u5316\u5e94\u5bf9\u7b56\u7565<\/h3>\n
\u7efc\u5408\u76d1\u63a7\u4e0e\u544a\u8b66\u4f53\u7cfb<\/h4>\n
yaml<\/p>\n
# \u5b8c\u6574\u76845xx\u9519\u8bef\u76d1\u63a7\u4eea\u8868\u677f\u914d\u7f6e
\ngrafana_dashboard:
\n title: "5xx Server Errors – Comprehensive Monitoring"
\n panels:
\n – title: "5xx Error Rate Trend"
\n type: "graph"
\n targets:
\n – expr: |
\n sum by (status) (
\n rate(http_requests_total{status=~"5.."}[5m])
\n ) \/
\n sum(rate(http_requests_total[5m]))<\/p>\n– title: "Top 5xx Error Sources"
\n type: "table"
\n targets:
\n – expr: |
\n topk(10,
\n sum by (service, endpoint, status) (
\n rate(http_requests_total{status=~"5.."}[5m])
\n )
\n )<\/p>\n– title: "Response Time vs 5xx Errors"
\n type: "graph"
\n targets:
\n – expr: |
\n histogram_quantile(0.95,
\n rate(http_response_time_seconds_bucket[5m])
\n )
\n – expr: |
\n rate(http_requests_total{status=~"5.."}[5m])<\/p>\n– title: "Error Recovery Time"
\n type: "stat"
\n targets:
\n – expr: |
\n time() –
\n timestamp(
\n max_over_time(
\n http_requests_total{status=~"5.."}[1h]
\n )
\n )<\/p>\nalerts:
\n – name: "5xx Error SLO Violation"
\n condition: |
\n (
\n sum(rate(http_requests_total{status=~"5.."}[5m]))
\n \/
\n sum(rate(http_requests_total[5m]))
\n ) > 0.01 # 1%\u9519\u8bef\u7387
\n for: "5m"
\n severity: "critical"<\/p>\n– name: "Error Burst Detection"
\n condition: |
\n rate(http_requests_total{status=~"5.."}[1m])
\n >
\n 10 * rate(http_requests_total{status=~"5.."}[5m])
\n for: "1m"
\n severity: "warning"<\/p>\n\u6839\u56e0\u5206\u6790\u51b3\u7b56\u6811
![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/07\/20260726181702-6a664f1e7da13.png\")
<\/h4>\n\u6301\u7eed\u6539\u8fdb\u4e0e\u77e5\u8bc6\u7ba1\u7406<\/h4>\n
python<\/p>\n
# \u6545\u969c\u77e5\u8bc6\u5e93\u7ba1\u7406\u7cfb\u7edf
\nclass IncidentKnowledgeBase:
\n """5xx\u9519\u8bef\u6545\u969c\u77e5\u8bc6\u5e93"""<\/p>\ndef __init__(self):
\n self.incidents = []
\n self.solutions = {}
\n self.patterns = {}<\/p>\ndef record_incident(self, error_code: int, context: Dict,
\n resolution: Dict):
\n """\u8bb0\u5f55\u6545\u969c\u4e8b\u4ef6"""
\n incident = {
\n 'id': self._generate_id(),
\n 'timestamp': time.time(),
\n 'error_code': error_code,
\n 'context': context,
\n 'resolution': resolution,
\n 'root_cause': self._analyze_root_cause(context),
\n 'prevention_measures': [],
\n 'related_incidents': self._find_related_incidents(error_code, context)
\n }<\/p>\nself.incidents.append(incident)<\/p>\n
# \u66f4\u65b0\u89e3\u51b3\u65b9\u6848\u5e93
\n self._update_solutions(error_code, resolution)<\/p>\n# \u66f4\u65b0\u6a21\u5f0f\u5e93
\n self._update_patterns(incident)<\/p>\nreturn incident<\/p>\n
def suggest_solutions(self, error_code: int, context: Dict) -> List[Dict]:
\n """\u6839\u636e\u9519\u8bef\u4ee3\u7801\u548c\u4e0a\u4e0b\u6587\u5efa\u8bae\u89e3\u51b3\u65b9\u6848"""
\n suggestions = []<\/p>\n# \u57fa\u4e8e\u9519\u8bef\u4ee3\u7801\u7684\u901a\u7528\u89e3\u51b3\u65b9\u6848
\n generic_solutions = self.solutions.get(error_code, [])
\n suggestions.extend(generic_solutions)<\/p>\n# \u57fa\u4e8e\u6a21\u5f0f\u7684\u89e3\u51b3\u65b9\u6848
\n matched_patterns = self._match_patterns(context)
\n for pattern in matched_patterns:
\n suggestions.extend(pattern.get('solutions', []))<\/p>\n# \u57fa\u4e8e\u76f8\u4f3c\u5386\u53f2\u4e8b\u4ef6\u7684\u89e3\u51b3\u65b9\u6848
\n similar_incidents = self._find_similar_incidents(context)
\n for incident in similar_incidents:
\n suggestions.append({
\n 'type': 'historical',
\n 'confidence': incident.get('similarity_score', 0),
\n 'solution': incident['resolution'],
\n 'reference': incident['id']
\n })<\/p>\n# \u53bb\u91cd\u548c\u6392\u5e8f
\n unique_suggestions = self._deduplicate_suggestions(suggestions)
\n sorted_suggestions = sorted(unique_suggestions,
\n key=lambda x: x.get('confidence', 0),
\n reverse=True)<\/p>\nreturn sorted_suggestions[:5] # \u8fd4\u56de\u524d5\u4e2a\u5efa\u8bae<\/p>\n
def generate_postmortem(self, incident_id: str) -> Dict:
\n """\u751f\u6210\u6545\u969c\u590d\u76d8\u62a5\u544a"""
\n incident = self._get_incident(incident_id)<\/p>\nif not incident:
\n return {}<\/p>\nreport = {
\n 'title': f"Postmortem: {incident['error_code']} Error",
\n 'incident_id': incident_id,
\n 'executive_summary': self._generate_summary(incident),
\n 'timeline': self._build_timeline(incident),
\n 'root_cause_analysis': incident['root_cause'],
\n 'impact_assessment': self._assess_impact(incident),
\n 'action_items': self._generate_action_items(incident),
\n 'lessons_learned': self._extract_lessons(incident),
\n 'preventive_measures': self._suggest_preventions(incident)
\n }<\/p>\nreturn report<\/p>\n
\u901a\u8fc7\u7cfb\u7edf\u5316\u7684\u65b9\u6cd5\u5904\u74065xx\u9519\u8bef，\u4ece\u9884\u9632\u3001\u68c0\u6d4b\u3001\u54cd\u5e94\u5230\u590d\u76d8，\u53ef\u4ee5\u6784\u5efa\u4e00\u4e2a\u5065\u58ee\u7684\u3001\u53ef\u89c2\u6d4b\u7684\u3001\u53ef\u6062\u590d\u7684\u7cfb\u7edf\u67b6\u6784\u3002\u8bb0\u4f4f，\u6bcf\u4e2a5xx\u9519\u8bef\u90fd\u662f\u4e00\u4e2a\u6539\u8fdb\u7cfb\u7edf\u7684\u673a\u4f1a\u3002<\/p>\n","protected":false},"excerpt":{"rendered":"
\u7b2c24\u7ae0：500 Internal Server Error – \u5185\u90e8\u670d\u52a1\u5668\u9519\u8bef24.1 \u6df1\u5ea6\u6280\u672f\u89e3\u6790：500\u9519\u8bef\u7684\u672c\u8d28500 Internal Server Error\u00a0\u662fHTTP\u534f\u8bae\u4e2d\u6700\u901a\u7528\u3001\u6700\u4ee4\u4eba\u56f0\u60d1\u7684\u670d\u52a1\u5668\u9519\u8bef\u72b6\u6001\u7801\u3002\u4e0e\u5ba2\u6237\u7aef\u9519\u8bef（4xx）\u4e0d\u540c，500\u9519\u8bef\u660e\u786e\u8868\u793a\u95ee\u9898\u51fa\u5728\u670d\u52a1\u5668\u7aef，\u4f46\u670d\u52a1\u5668\u65e0\u6cd5\u6216\u4e0d\u613f\u63d0\u4f9b\u66f4\u5177\u4f53\u7684\u4fe1\u606f\u300224.1.1 \u6280\u672f\u89c4\u683c\u4e0e\u534f\u8bae\u5b9a\u4e49HTTP\/1.1 RFC 7231\u5b9a\u4e49<\/p>\n","protected":false},"author":2,"featured_media":85156,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[151,43,191],"topic":[],"class_list":["post-85162","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-server","tag-http","tag-43","tag-191"],"yoast_head":"\n
HTTP \u72b6\u6001\u7801\uff1a\u5ba2\u6237\u7aef\u4e0e\u670d\u52a1\u5668\u7684\u901a\u4fe1\u8bed\u8a00\u2014\u2014\u7b2c\u4e94\u90e8\u5206\uff1a\u670d\u52a1\u5668\u9519\u8bef\u72b6\u6001\u7801\uff085xx\uff09\u7cfb\u7edf\u5206\u6790 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.wsisp.com\/helps\/85162.html\" \/>\n<meta property=\"og:locale\" content=\"zh_CN\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"HTTP \u72b6\u6001\u7801\uff1a\u5ba2\u6237\u7aef\u4e0e\u670d\u52a1\u5668\u7684\u901a\u4fe1\u8bed\u8a00\u2014\u2014\u7b2c\u4e94\u90e8\u5206\uff1a\u670d\u52a1\u5668\u9519\u8bef\u72b6\u6001\u7801\uff085xx\uff09\u7cfb\u7edf\u5206\u6790 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\" \/>\n<meta property=\"og:description\" content=\"\u7b2c24\u7ae0：500 Internal Server Error - \u5185\u90e8\u670d\u52a1\u5668\u9519\u8bef24.1 \u6df1\u5ea6\u6280\u672f\u89e3\u6790：500\u9519\u8bef\u7684\u672c\u8d28500 Internal Server Error\u00a0\u662fHTTP\u534f\u8bae\u4e2d\u6700\u901a\u7528\u3001\u6700\u4ee4\u4eba\u56f0\u60d1\u7684\u670d\u52a1\u5668\u9519\u8bef\u72b6\u6001\u7801\u3002\u4e0e\u5ba2\u6237\u7aef\u9519\u8bef（4xx）\u4e0d\u540c，500\u9519\u8bef\u660e\u786e\u8868\u793a\u95ee\u9898\u51fa\u5728\u670d\u52a1\u5668\u7aef，\u4f46\u670d\u52a1\u5668\u65e0\u6cd5\u6216\u4e0d\u613f\u63d0\u4f9b\u66f4\u5177\u4f53\u7684\u4fe1\u606f\u300224.1.1 \u6280\u672f\u89c4\u683c\u4e0e\u534f\u8bae\u5b9a\u4e49HTTP\/1.1 RFC 7231\u5b9a\u4e49\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.wsisp.com\/helps\/85162.html\" \/>\n<meta property=\"og:site_name\" content=\"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\" \/>\n<meta property=\"article:published_time\" content=\"2026-07-26T18:17:05+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/07\/20260726181654-6a664f16b62ae.png\" \/>\n<meta name=\"author\" content=\"admin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u4f5c\u8005\" \/>\n\t<meta name=\"twitter:data1\" content=\"admin\" \/>\n\t<meta name=\"twitter:label2\" content=\"\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4\" \/>\n\t<meta name=\"twitter:data2\" content=\"69 \u5206\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/85162.html\",\"url\":\"https:\/\/www.wsisp.com\/helps\/85162.html\",\"name\":\"HTTP \u72b6\u6001\u7801\uff1a\u5ba2\u6237\u7aef\u4e0e\u670d\u52a1\u5668\u7684\u901a\u4fe1\u8bed\u8a00\u2014\u2014\u7b2c\u4e94\u90e8\u5206\uff1a\u670d\u52a1\u5668\u9519\u8bef\u72b6\u6001\u7801\uff085xx\uff09\u7cfb\u7edf\u5206\u6790 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\",\"isPartOf\":{\"@id\":\"https:\/\/www.wsisp.com\/helps\/#website\"},\"datePublished\":\"2026-07-26T18:17:05+00:00\",\"dateModified\":\"2026-07-26T18:17:05+00:00\",\"author\":{\"@id\":\"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41\"},\"breadcrumb\":{\"@id\":\"https:\/\/www.wsisp.com\/helps\/85162.html#breadcrumb\"},\"inLanguage\":\"zh-Hans\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.wsisp.com\/helps\/85162.html\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/85162.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"\u9996\u9875\",\"item\":\"https:\/\/www.wsisp.com\/helps\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"HTTP \u72b6\u6001\u7801\uff1a\u5ba2\u6237\u7aef\u4e0e\u670d\u52a1\u5668\u7684\u901a\u4fe1\u8bed\u8a00\u2014\u2014\u7b2c\u4e94\u90e8\u5206\uff1a\u670d\u52a1\u5668\u9519\u8bef\u72b6\u6001\u7801\uff085xx\uff09\u7cfb\u7edf\u5206\u6790\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/#website\",\"url\":\"https:\/\/www.wsisp.com\/helps\/\",\"name\":\"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\",\"description\":\"\u9999\u6e2f\u670d\u52a1\u5668_\u9999\u6e2f\u4e91\u670d\u52a1\u5668\u8d44\u8baf_\u670d\u52a1\u5668\u5e2e\u52a9\u6587\u6863_\u670d\u52a1\u5668\u6559\u7a0b\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.wsisp.com\/helps\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"zh-Hans\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41\",\"name\":\"admin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"zh-Hans\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery\",\"contentUrl\":\"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery\",\"caption\":\"admin\"},\"sameAs\":[\"http:\/\/wp.wsisp.com\"],\"url\":\"https:\/\/www.wsisp.com\/helps\/author\/admin\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"HTTP \u72b6\u6001\u7801\uff1a\u5ba2\u6237\u7aef\u4e0e\u670d\u52a1\u5668\u7684\u901a\u4fe1\u8bed\u8a00\u2014\u2014\u7b2c\u4e94\u90e8\u5206\uff1a\u670d\u52a1\u5668\u9519\u8bef\u72b6\u6001\u7801\uff085xx\uff09\u7cfb\u7edf\u5206\u6790 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.wsisp.com\/helps\/85162.html","og_locale":"zh_CN","og_type":"article","og_title":"HTTP \u72b6\u6001\u7801\uff1a\u5ba2\u6237\u7aef\u4e0e\u670d\u52a1\u5668\u7684\u901a\u4fe1\u8bed\u8a00\u2014\u2014\u7b2c\u4e94\u90e8\u5206\uff1a\u670d\u52a1\u5668\u9519\u8bef\u72b6\u6001\u7801\uff085xx\uff09\u7cfb\u7edf\u5206\u6790 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","og_description":"\u7b2c24\u7ae0：500 Internal Server Error - \u5185\u90e8\u670d\u52a1\u5668\u9519\u8bef24.1 \u6df1\u5ea6\u6280\u672f\u89e3\u6790：500\u9519\u8bef\u7684\u672c\u8d28500 Internal Server Error\u00a0\u662fHTTP\u534f\u8bae\u4e2d\u6700\u901a\u7528\u3001\u6700\u4ee4\u4eba\u56f0\u60d1\u7684\u670d\u52a1\u5668\u9519\u8bef\u72b6\u6001\u7801\u3002\u4e0e\u5ba2\u6237\u7aef\u9519\u8bef（4xx）\u4e0d\u540c，500\u9519\u8bef\u660e\u786e\u8868\u793a\u95ee\u9898\u51fa\u5728\u670d\u52a1\u5668\u7aef，\u4f46\u670d\u52a1\u5668\u65e0\u6cd5\u6216\u4e0d\u613f\u63d0\u4f9b\u66f4\u5177\u4f53\u7684\u4fe1\u606f\u300224.1.1 \u6280\u672f\u89c4\u683c\u4e0e\u534f\u8bae\u5b9a\u4e49HTTP\/1.1 RFC 7231\u5b9a\u4e49","og_url":"https:\/\/www.wsisp.com\/helps\/85162.html","og_site_name":"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","article_published_time":"2026-07-26T18:17:05+00:00","og_image":[{"url":"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2026\/07\/20260726181654-6a664f16b62ae.png"}],"author":"admin","twitter_card":"summary_large_image","twitter_misc":{"\u4f5c\u8005":"admin","\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4":"69 \u5206"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.wsisp.com\/helps\/85162.html","url":"https:\/\/www.wsisp.com\/helps\/85162.html","name":"HTTP \u72b6\u6001\u7801\uff1a\u5ba2\u6237\u7aef\u4e0e\u670d\u52a1\u5668\u7684\u901a\u4fe1\u8bed\u8a00\u2014\u2014\u7b2c\u4e94\u90e8\u5206\uff1a\u670d\u52a1\u5668\u9519\u8bef\u72b6\u6001\u7801\uff085xx\uff09\u7cfb\u7edf\u5206\u6790 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","isPartOf":{"@id":"https:\/\/www.wsisp.com\/helps\/#website"},"datePublished":"2026-07-26T18:17:05+00:00","dateModified":"2026-07-26T18:17:05+00:00","author":{"@id":"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41"},"breadcrumb":{"@id":"https:\/\/www.wsisp.com\/helps\/85162.html#breadcrumb"},"inLanguage":"zh-Hans","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.wsisp.com\/helps\/85162.html"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.wsisp.com\/helps\/85162.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"\u9996\u9875","item":"https:\/\/www.wsisp.com\/helps"},{"@type":"ListItem","position":2,"name":"HTTP \u72b6\u6001\u7801\uff1a\u5ba2\u6237\u7aef\u4e0e\u670d\u52a1\u5668\u7684\u901a\u4fe1\u8bed\u8a00\u2014\u2014\u7b2c\u4e94\u90e8\u5206\uff1a\u670d\u52a1\u5668\u9519\u8bef\u72b6\u6001\u7801\uff085xx\uff09\u7cfb\u7edf\u5206\u6790"}]},{"@type":"WebSite","@id":"https:\/\/www.wsisp.com\/helps\/#website","url":"https:\/\/www.wsisp.com\/helps\/","name":"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","description":"\u9999\u6e2f\u670d\u52a1\u5668_\u9999\u6e2f\u4e91\u670d\u52a1\u5668\u8d44\u8baf_\u670d\u52a1\u5668\u5e2e\u52a9\u6587\u6863_\u670d\u52a1\u5668\u6559\u7a0b","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.wsisp.com\/helps\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"zh-Hans"},{"@type":"Person","@id":"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41","name":"admin","image":{"@type":"ImageObject","inLanguage":"zh-Hans","@id":"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/image\/","url":"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery","contentUrl":"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery","caption":"admin"},"sameAs":["http:\/\/wp.wsisp.com"],"url":"https:\/\/www.wsisp.com\/helps\/author\/admin"}]}},"_links":{"self":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/posts\/85162","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/comments?post=85162"}],"version-history":[{"count":0,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/posts\/85162\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/media\/85156"}],"wp:attachment":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/media?parent=85162"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/categories?post=85162"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/tags?post=85162"},{"taxonomy":"topic","embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/topic?post=85162"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
- \n
- \n
- \n
- \n
- \n
- \n
- \n
- \n
- \n
- \n
- \n
- \n