AWS USDT代付 ｜ Payment 解决方案执行摘要
CloudFront 缓存键优化是 CDN 成本控制的核心环节。通过精确控制缓存键组成、合理设计缓存策略，企业可以显著提升缓存命中率，降低回源成本和延迟。本文提供完整的缓存键优化框架，包括设计原则、实施方法、监控指标和常见问题解决方案。
关键价值
- 成本降低：优化后可减少 40-60% 的回源请求
- 性能提升：P99 延迟降低 50-70%
- 带宽节省：源站带宽消耗减少 60-80%
- 可用性增强：减少源站压力，提高整体可用性
第一部分：缓存键基础概念
1.1 缓存键组成要素
CloudFront 缓存键决定了对象在边缘节点的唯一性。默认情况下，缓存键包含：
基础组成
-
域名（Host Header）
- 分布式域名：d111111abcdef8.cloudfront.net
- 替代域名（CNAME）：cdn.example.com
- 影响：不同域名即使相同路径也视为不同对象
-
URI 路径
- 完整路径：/images/product/item-123.jpg
- 大小写敏感：/Image.jpg 与 /image.jpg 是不同对象
- 编码处理：空格和特殊字符的 URL 编码
-
查询字符串（可选）
- 参数顺序：?a=1&b=2 与 ?b=2&a=1 可能是不同对象
- 参数选择：可配置包含全部、部分或忽略
- 值敏感性：参数值的大小写和编码
1.2 高级缓存键配置
请求头作为缓存键
配置示例：
- Accept-Language: 根据语言缓存不同版本
- CloudFront-Viewer-Country: 根据国家缓存
- CloudFront-Is-Mobile-Viewer: 根据设备类型缓存
- Authorization: 个性化内容缓存（谨慎使用）
Cookie 作为缓存键
使用场景：
- 会话相关内容：用户偏好设置
- A/B 测试：实验组标识
- 个性化推荐：用户分组标识
注意事项：
- Cookie 会显著降低缓存命中率
- 仅转发必要的 Cookie
- 考虑使用查询字符串替代
1.3 缓存键设计原则
最小化原则
- 仅包含影响内容的参数
- 移除跟踪参数（utm_*, fbclid 等）
- 标准化参数顺序
分层设计
静态资源层：
/static/* - 忽略所有查询字符串和 Cookie
/images/* - 仅保留版本参数（v=）
/css/* - 保留版本和主题参数
动态内容层：
/api/* - 保留所有查询字符串
/user/* - 包含认证 Cookie
/search/* - 保留搜索相关参数
第二部分：缓存命中率优化策略
2.1 查询字符串优化
参数白名单策略
# CloudFormation 配置示例
CacheBehavior:
QueryStringCacheKeys:
- Items:
- "category"
- "sort"
- "page"
# 忽略跟踪参数：utm_source, utm_medium, fbclid, gclid
参数标准化处理
// Lambda@Edge 函数示例
exports.handler = async (event) => {
const request = event.Records[0].cf.request;
const params = new URLSearchParams(request.querystring);
// 移除跟踪参数
const trackingParams = ['utm_source', 'utm_medium', 'utm_campaign',
'fbclid', 'gclid', 'ref'];
trackingParams.forEach(param => params.delete(param));
// 参数排序
const sortedParams = new URLSearchParams(
[...params.entries()].sort()
);
request.querystring = sortedParams.toString();
return request;
};
2.2 请求头优化
设备检测优化
# 使用 CloudFront 设备检测头替代 User-Agent
CacheBehaviors:
- PathPattern: "/mobile/*"
Headers:
- CloudFront-Is-Mobile-Viewer
- CloudFront-Is-Tablet-Viewer
# 不要使用完整的 User-Agent
地理位置缓存
# 国家级缓存策略
def configure_geo_caching():
return {
'Headers': {
'Quantity': 1,
'Items': ['CloudFront-Viewer-Country']
},
'GeoRestriction': {
'RestrictionType': 'whitelist',
'Items': ['US', 'CA', 'GB', 'DE', 'JP', 'CN']
}
}
2.3 内容变体管理
图片格式自适应
// Lambda@Edge - Viewer Request
exports.handler = async (event) => {
const request = event.Records[0].cf.request;
const headers = request.headers;
// 检测 WebP 支持
const acceptHeader = headers['accept'] ? headers['accept'][0].value : '';
const supportsWebP = acceptHeader.includes('image/webp');
if (supportsWebP && request.uri.match(/\.(jpg|jpeg|png)$/i)) {
// 添加 WebP 变体标识
request.headers['x-image-format'] = [{
key: 'X-Image-Format',
value: 'webp'
}];
}
return request;
};
响应式图片处理
# 源站配置示例（Nginx）
location ~* \.(jpg|jpeg|png)$ {
# 根据请求参数生成不同尺寸
if ($arg_w) {
rewrite ^(.*)\.([^.]+)$ /resize?file=$1.$2&width=$arg_w last;
}
# 缓存不同尺寸变体
add_header Cache-Control "public, max-age=31536000";
add_header Vary "Accept, X-Image-Format";
}
第三部分：缓存策略设计
3.1 分层缓存架构
四层缓存模型
Layer1_Static:
PathPattern: "/static/*"
TTL:
MinTTL: 86400 # 1天
DefaultTTL: 604800 # 7天
MaxTTL: 31536000 # 1年
QueryString: false
Headers: []
Cookies: none
Layer2_Images:
PathPattern: "/images/*"
TTL:
MinTTL: 3600 # 1小时
DefaultTTL: 86400 # 1天
MaxTTL: 2592000 # 30天
QueryString:
- "v" # 版本号
- "w" # 宽度
- "h" # 高度
Headers:
- "CloudFront-Is-Mobile-Viewer"
Layer3_API:
PathPattern: "/api/*"
TTL:
MinTTL: 0
DefaultTTL: 60 # 1分钟
MaxTTL: 300 # 5分钟
QueryString: all
Headers:
- "Authorization"
- "Accept"
Layer4_Dynamic:
PathPattern: "/*" # 默认行为
TTL:
MinTTL: 0
DefaultTTL: 0
MaxTTL: 0
QueryString: all
Headers: all
Cookies: all
3.2 缓存失效策略
版本化策略
// 构建时生成版本号
const webpack = require('webpack');
const buildVersion = Date.now();
module.exports = {
output: {
filename: `[name].${buildVersion}.js`,
publicPath: `/static/js/`
},
plugins: [
new webpack.DefinePlugin({
'process.env.BUILD_VERSION': JSON.stringify(buildVersion)
})
]
};
智能失效管理
import boto3
from datetime import datetime
import hashlib
class CacheInvalidator:
def __init__(self, distribution_id):
self.client = boto3.client('cloudfront')
self.distribution_id = distribution_id
def invalidate_smart(self, paths):
"""智能失效：合并路径，批量处理"""
# 路径去重和通配符优化
optimized_paths = self._optimize_paths(paths)
# 批量失效（每批最多3000个路径）
batch_size = 3000
for i in range(0, len(optimized_paths), batch_size):
batch = optimized_paths[i:i+batch_size]
self._create_invalidation(batch)
def _optimize_paths(self, paths):
"""优化失效路径列表"""
path_tree = {}
for path in paths:
parts = path.split('/')
current = path_tree
for part in parts[:-1]:
if part not in current:
current[part] = {}
current = current[part]
# 标记叶节点
current[parts[-1]] = True
# 生成优化路径
optimized = []
self._build_paths(path_tree, '', optimized)
return optimized
def _build_paths(self, tree, prefix, result):
"""递归构建优化路径"""
if len(tree) > 10: # 超过10个子项使用通配符
result.append(f"{prefix}/*")
else:
for key, value in tree.items():
path = f"{prefix}/{key}" if prefix else key
if value is True:
result.append(path)
else:
self._build_paths(value, path, result)
def _create_invalidation(self, paths):
"""创建失效请求"""
caller_reference = f"{datetime.now().isoformat()}-{len(paths)}"
response = self.client.create_invalidation(
DistributionId=self.distribution_id,
InvalidationBatch={
'Paths': {
'Quantity': len(paths),
'Items': paths
},
'CallerReference': caller_reference
}
)
return response['Invalidation']['Id']
3.3 缓存预热策略
关键资源预热
import asyncio
import aiohttp
from urllib.parse import urljoin
class CacheWarmer:
def __init__(self, base_url, concurrency=10):
self.base_url = base_url
self.semaphore = asyncio.Semaphore(concurrency)
async def warm_critical_paths(self):
"""预热关键路径"""
critical_paths = [
'/',
'/index.html',
'/static/css/main.css',
'/static/js/app.js',
'/api/config',
'/images/logo.png'
]
# 添加设备变体
device_headers = [
{}, # 桌面
{'CloudFront-Is-Mobile-Viewer': 'true'}, # 移动
{'CloudFront-Is-Tablet-Viewer': 'true'} # 平板
]
tasks = []
for path in critical_paths:
for headers in device_headers:
url = urljoin(self.base_url, path)
tasks.append(self._warm_url(url, headers))
results = await asyncio.gather(*tasks, return_exceptions=True)
return self._analyze_results(results)
async def _warm_url(self, url, headers=None):
"""预热单个URL"""
async with self.semaphore:
async with aiohttp.ClientSession() as session:
try:
async with session.get(url, headers=headers) as response:
return {
'url': url,
'status': response.status,
'cache_status': response.headers.get('X-Cache', 'UNKNOWN'),
'headers': dict(response.headers)
}
except Exception as e:
return {
'url': url,
'error': str(e)
}
def _analyze_results(self, results):
"""分析预热结果"""
summary = {
'total': len(results),
'success': 0,
'cache_hit': 0,
'cache_miss': 0,
'errors': []
}
for result in results:
if 'error' in result:
summary['errors'].append(result)
else:
summary['success'] += 1
cache_status = result.get('cache_status', '')
if 'Hit' in cache_status:
summary['cache_hit'] += 1
elif 'Miss' in cache_status:
summary['cache_miss'] += 1
return summary
第四部分：监控与优化
4.1 关键指标监控
CloudWatch 指标配置
import boto3
from datetime import datetime, timedelta
class CacheMetricsAnalyzer:
def __init__(self, distribution_id):
self.cloudwatch = boto3.client('cloudwatch')
self.distribution_id = distribution_id
def get_cache_hit_rate(self, period_hours=24):
"""获取缓存命中率"""
end_time = datetime.utcnow()
start_time = end_time - timedelta(hours=period_hours)
# 获取总请求数
total_requests = self._get_metric_sum(
'Requests', start_time, end_time
)
# 获取缓存命中数
cache_hits = self._get_metric_sum(
'CacheHitRate', start_time, end_time
)
if total_requests > 0:
hit_rate = (cache_hits / total_requests) * 100
return {
'hit_rate': round(hit_rate, 2),
'total_requests': total_requests,
'cache_hits': cache_hits,
'cache_misses': total_requests - cache_hits
}
return None
def analyze_cache_behavior(self):
"""分析缓存行为模式"""
metrics = {
'by_path': self._analyze_by_path(),
'by_query_string': self._analyze_by_query(),
'by_header': self._analyze_by_header(),
'by_time': self._analyze_by_time()
}
return self._generate_recommendations(metrics)
def _analyze_by_path(self):
"""按路径分析缓存效率"""
# 使用 CloudFront 访问日志分析
query = """
SELECT
uri_stem as path,
COUNT(*) as requests,
SUM(CASE WHEN x_edge_result_type LIKE '%Hit' THEN 1 ELSE 0 END) as hits,
AVG(time_taken) as avg_latency
FROM cloudfront_logs
WHERE date = today()
GROUP BY uri_stem
ORDER BY requests DESC
LIMIT 100
"""
# 这里使用 Athena 查询
return self._run_athena_query(query)
def _generate_recommendations(self, metrics):
"""生成优化建议"""
recommendations = []
# 分析低命中率路径
for path_data in metrics['by_path']:
hit_rate = path_data['hits'] / path_data['requests']
if hit_rate < 0.5 and path_data['requests'] > 1000:
recommendations.append({
'type': 'LOW_HIT_RATE',
'path': path_data['path'],
'current_hit_rate': hit_rate,
'potential_savings': path_data['requests'] * 0.5 * 0.001, # 估算节省
'action': '考虑增加TTL或减少缓存键变量'
})
# 分析查询字符串影响
qs_impact = metrics['by_query_string']
if qs_impact['with_qs_hit_rate'] < qs_impact['without_qs_hit_rate'] * 0.7:
recommendations.append({
'type': 'QUERY_STRING_IMPACT',
'impact': f"{(1 - qs_impact['with_qs_hit_rate']/qs_impact['without_qs_hit_rate'])*100:.1f}%",
'action': '考虑移除不必要的查询字符串参数'
})
return recommendations
4.2 性能分析工具
缓存效率分析器
class CacheEfficiencyAnalyzer:
def __init__(self, log_bucket, distribution_id):
self.s3 = boto3.client('s3')
self.athena = boto3.client('athena')
self.log_bucket = log_bucket
self.distribution_id = distribution_id
def analyze_cache_key_impact(self):
"""分析缓存键配置对命中率的影响"""
analysis = {
'query_string_impact': self._analyze_query_string_impact(),
'header_impact': self._analyze_header_impact(),
'cookie_impact': self._analyze_cookie_impact(),
'optimal_ttl': self._calculate_optimal_ttl()
}
return analysis
def _analyze_query_string_impact(self):
"""分析查询字符串对缓存的影响"""
query = """
WITH query_analysis AS (
SELECT
CASE
WHEN uri_query = '-' THEN 'no_query'
ELSE 'with_query'
END as query_type,
COUNT(*) as requests,
SUM(CASE WHEN x_edge_result_type LIKE '%Hit' THEN 1 ELSE 0 END) as hits,
SUM(sc_bytes) as bytes_served,
AVG(time_taken) as avg_latency
FROM cloudfront_logs
WHERE date >= current_date - interval '7' day
GROUP BY 1
)
SELECT
query_type,
requests,
hits,
CAST(hits AS DOUBLE) / requests * 100 as hit_rate,
bytes_served / 1024 / 1024 as mb_served,
avg_latency
FROM query_analysis
"""
results = self._run_athena_query(query)
# 识别高频查询参数
param_query = """
SELECT
regexp_extract(uri_query, '([^&=]+)=', 1) as param_name,
COUNT(DISTINCT uri_query) as unique_values,
COUNT(*) as requests,
SUM(CASE WHEN x_edge_result_type LIKE '%Hit' THEN 1 ELSE 0 END) as hits
FROM cloudfront_logs
WHERE date >= current_date - interval '7' day
AND uri_query != '-'
GROUP BY 1
HAVING param_name IS NOT NULL
ORDER BY requests DESC
LIMIT 20
"""
param_results = self._run_athena_query(param_query)
return {
'summary': results,
'top_parameters': param_results,
'recommendations': self._generate_qs_recommendations(param_results)
}
def _calculate_optimal_ttl(self):
"""计算最优TTL值"""
query = """
WITH request_patterns AS (
SELECT
uri_stem,
date_diff('second',
MIN(parse_datetime(time, 'HH:mm:ss')),
MAX(parse_datetime(time, 'HH:mm:ss'))
) / COUNT(DISTINCT x_forwarded_for) as avg_request_interval
FROM cloudfront_logs
WHERE date >= current_date - interval '30' day
GROUP BY uri_stem
HAVING COUNT(*) > 100
)
SELECT
CASE
WHEN uri_stem LIKE '%.js' OR uri_stem LIKE '%.css' THEN 'static_assets'
WHEN uri_stem LIKE '%.jpg' OR uri_stem LIKE '%.png' THEN 'images'
WHEN uri_stem LIKE '/api/%' THEN 'api'
ELSE 'html'
END as content_type,
PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY avg_request_interval) as median_interval,
PERCENTILE_CONT(0.9) WITHIN GROUP (ORDER BY avg_request_interval) as p90_interval,
COUNT(*) as path_count
FROM request_patterns
GROUP BY 1
"""
results = self._run_athena_query(query)
ttl_recommendations = []
for row in results:
content_type = row['content_type']
median_interval = row['median_interval']
# 基于请求间隔推荐TTL
if content_type == 'static_assets':
recommended_ttl = 86400 * 30 # 30天
elif content_type == 'images':
recommended_ttl = 86400 * 7 # 7天
elif content_type == 'api':
recommended_ttl = min(300, median_interval * 0.5) # 最多5分钟
else:
recommended_ttl = min(3600, median_interval * 0.7) # 最多1小时
ttl_recommendations.append({
'content_type': content_type,
'recommended_ttl': recommended_ttl,
'median_request_interval': median_interval,
'path_count': row['path_count']
})
return ttl_recommendations
4.3 成本影响分析
成本计算器
class CloudFrontCostCalculator:
def __init__(self):
# 2024年定价（美国区域）
self.pricing = {
'data_transfer_out': {
'first_10tb': 0.085,
'next_40tb': 0.080,
'next_100tb': 0.060,
'next_350tb': 0.040,
'over_500tb': 0.030
},
'http_requests': {
'http': 0.0075, # 每10,000请求
'https': 0.0100 # 每10,000请求
},
'invalidation': {
'per_path': 0.005 # 超过1000个路径后每个路径
},
'origin_requests': {
'per_10k': 0.0075
}
}
def calculate_optimization_savings(self, metrics):
"""计算优化后的成本节省"""
current_cost = self._calculate_current_cost(metrics)
optimized_cost = self._calculate_optimized_cost(metrics)
savings = {
'monthly_savings': current_cost['total'] - optimized_cost['total'],
'annual_savings': (current_cost['total'] - optimized_cost['total']) * 12,
'percentage_reduction': ((current_cost['total'] - optimized_cost['total']) / current_cost['total']) * 100,
'breakdown': {
'data_transfer': current_cost['data_transfer'] - optimized_cost['data_transfer'],
'requests': current_cost['requests'] - optimized_cost['requests'],
'origin': current_cost['origin'] - optimized_cost['origin']
}
}
return savings
def _calculate_current_cost(self, metrics):
"""计算当前成本"""
data_gb = metrics['data_transfer_gb']
total_requests = metrics['total_requests']
cache_hit_rate = metrics['cache_hit_rate']
# 数据传输成本
data_cost = self._calculate_data_transfer_cost(data_gb)
# 请求成本
request_cost = (total_requests / 10000) * self.pricing['http_requests']['https']
# 回源成本
origin_requests = total_requests * (1 - cache_hit_rate)
origin_cost = (origin_requests / 10000) * self.pricing['origin_requests']['per_10k']
return {
'data_transfer': data_cost,
'requests': request_cost,
'origin': origin_cost,
'total': data_cost + request_cost + origin_cost
}
def _calculate_optimized_cost(self, metrics):
"""计算优化后成本"""
# 假设优化后缓存命中率提升到90%
optimized_hit_rate = 0.90
data_gb = metrics['data_transfer_gb']
total_requests = metrics['total_requests']
# 数据传输成本（略有降低due to better compression）
data_cost = self._calculate_data_transfer_cost(data_gb * 0.95)
# 请求成本不变
request_cost = (total_requests / 10000) * self.pricing['http_requests']['https']
# 回源成本大幅降低
origin_requests = total_requests * (1 - optimized_hit_rate)
origin_cost = (origin_requests / 10000) * self.pricing['origin_requests']['per_10k']
return {
'data_transfer': data_cost,
'requests': request_cost,
'origin': origin_cost,
'total': data_cost + request_cost + origin_cost
}
第五部分：常见问题与解决方案
5.1 Anti-Pattern 清单
1. 过度使用查询字符串
问题：将所有查询字符串参数包含在缓存键中
影响：缓存命中率极低，存储浪费严重
解决方案：
# 错误配置
QueryString: true # 包含所有参数
# 正确配置
QueryString:
QueryStringCacheKeys:
- Items:
- "category"
- "page"
- "sort"
# 排除：utm_*, fbclid, gclid, ref
2. User-Agent 作为缓存键
问题：使用完整 User-Agent 头
影响：每个浏览器版本创建独立缓存
解决方案：
# 使用 CloudFront 设备检测头
headers = [
'CloudFront-Is-Desktop-Viewer',
'CloudFront-Is-Mobile-Viewer',
'CloudFront-Is-SmartTV-Viewer',
'CloudFront-Is-Tablet-Viewer'
]
3. 忽略缓存控制头
问题：不设置或错误设置 Cache-Control
影响：CloudFront 使用默认 24 小时 TTL
解决方案：
# 源站正确设置缓存头
def set_cache_headers(content_type):
headers = {}
if content_type.startswith('image/'):
headers['Cache-Control'] = 'public, max-age=2592000, immutable' # 30天
elif content_type in ['text/css', 'application/javascript']:
headers['Cache-Control'] = 'public, max-age=31536000, immutable' # 1年
elif content_type == 'text/html':
headers['Cache-Control'] = 'public, max-age=300, must-revalidate' # 5分钟
else:
headers['Cache-Control'] = 'public, max-age=3600' # 1小时
return headers
5.2 优化案例研究
案例1：电商网站优化
背景：
- 月流量：500TB
- 请求数：10亿次/月
- 初始缓存命中率：45%
优化措施：
- 移除跟踪参数（utm_*, fbclid）
- 实施智能图片格式选择
- 分离静态和动态内容路径
- 优化 TTL 策略
结果：
- 缓存命中率提升至 85%
- 回源请求减少 70%
- 月成本降低 $12,000（40%）
案例2：SaaS 应用优化
背景：
- API 请求为主
- 高度个性化内容
- 初始缓存命中率：15%
优化措施：
- 识别可缓存 API 端点
- 实施用户分组缓存策略
- 使用 Lambda@Edge 进行请求规范化
- 引入短期缓存（1-5分钟）
结果：
- 缓存命中率提升至 65%
- API 响应时间降低 60%
- 源站负载降低 50%
5.3 故障排除指南
诊断工具集
# 1. 测试缓存键变化
curl -I "https://d111111abcdef8.cloudfront.net/image.jpg" \
-H "Accept: image/webp" \
-H "CloudFront-Viewer-Country: US"
# 2. 查看缓存状态
curl -I "https://example.com/api/data" | grep -E "X-Cache|Age|Cache-Control"
# 3. 验证 TTL 设置
aws cloudfront get-distribution-config --id E1234567890ABC \
--query "DistributionConfig.CacheBehaviors[*].[PathPattern,DefaultTTL]"
常见问题解决
class CacheTroubleshooter:
def diagnose_low_hit_rate(self, distribution_id, path_pattern):
"""诊断低命中率原因"""
checks = []
# 检查1：查询字符串配置
qs_config = self._check_query_string_config(distribution_id, path_pattern)
if qs_config['all_included']:
checks.append({
'issue': 'Including all query strings',
'impact': 'HIGH',
'solution': 'Use query string whitelist'
})
# 检查2：Cookie 转发
cookie_config = self._check_cookie_config(distribution_id, path_pattern)
if cookie_config['forward_all']:
checks.append({
'issue': 'Forwarding all cookies',
'impact': 'HIGH',
'solution': 'Forward only necessary cookies'
})
# 检查3：TTL 设置
ttl_config = self._check_ttl_config(distribution_id, path_pattern)
if ttl_config['default_ttl'] < 60:
checks.append({
'issue': 'TTL too short',
'impact': 'MEDIUM',
'solution': f"Increase TTL from {ttl_config['default_ttl']}s"
})
# 检查4：请求头配置
header_config = self._check_header_config(distribution_id, path_pattern)
if 'User-Agent' in header_config['forwarded_headers']:
checks.append({
'issue': 'Forwarding User-Agent header',
'impact': 'HIGH',
'solution': 'Use CloudFront device detection headers'
})
return {
'path_pattern': path_pattern,
'issues_found': len(checks),
'checks': checks,
'estimated_improvement': self._estimate_improvement(checks)
}
第六部分：最佳实践总结
6.1 设计原则
- 最小化缓存键复杂度：仅包含必要的变量
- 标准化请求格式：使用 Lambda@Edge 规范化
- 分层缓存策略：不同内容类型不同策略
- 版本化静态资源：使用文件名版本而非查询字符串
- 监控驱动优化：基于数据持续调整
6.2 实施检查清单
- 审计当前缓存键配置
- 识别并移除不必要的查询参数
- 评估 Cookie 和请求头需求
- 实施内容分类和路径模式
- 配置适当的 TTL 值
- 部署监控和告警
- 建立缓存预热流程
- 制定失效策略
- 进行性能基准测试
- 计算 ROI 和成本节省
6.3 持续优化流程
- 周度审查：检查缓存命中率趋势
- 月度分析：深入分析低效路径
- 季度优化：实施重大配置更改
- 年度评估：全面成本效益分析
总结
CloudFront 缓存键优化是一个持续的过程，需要深入理解业务需求、用户行为和技术限制。通过系统化的方法、数据驱动的决策和持续的监控优化，企业可以显著提升 CDN 性能，降低成本，改善用户体验。
关键要点：
- 缓存命中率每提升 10%，可降低约 15-20% 的 CDN 成本
- 合理的缓存键设计可以将命中率从 40% 提升到 85%+
- 投资回报期通常在 2-3 个月内
- 需要平衡缓存效率和内容新鲜度
立即开始优化您的 CloudFront 缓存配置，实现成本和性能的双重提升。
