RI/SP 评估清单：企业级采购决策的完整指南（可打印模板）

概述

Reserved Instances (RI) 和 Savings Plans (SP) 是 AWS 成本优化的核心工具，可以带来 20-72% 的成本节省。但错误的采购决策可能导致资源浪费和财务损失。本文提供一套经过实战验证的评估框架和可打印的检查清单，帮助您做出数据驱动的采购决策。

第一部分：评估前准备

1.1 数据收集清单

必需数据项

• 使用历史数据

  • 最近 3 个月的详细使用数据
  • 最近 12 个月的月度趋势
  • 峰值和低谷使用模式
  • 季节性变化记录

• 成本数据

  • 当前按需成本明细
  • 现有 RI/SP 覆盖情况
  • 未覆盖的按需支出
  • Spot 实例使用比例

• 业务数据

  • 未来 12 个月的业务预测
  • 计划中的项目和扩展
  • 可能的架构变更
  • 预算限制和财务目标

1.2 工具准备

# RI/SP 评估数据准备脚本
import boto3
import pandas as pd
from datetime import datetime, timedelta

class RISPDataCollector:
    def __init__(self):
        self.ce_client = boto3.client('ce')
        self.start_date = (datetime.now() - timedelta(days=90)).strftime('%Y-%m-%d')
        self.end_date = datetime.now().strftime('%Y-%m-%d')
    
    def collect_usage_data(self):
        """收集使用数据"""
        response = self.ce_client.get_cost_and_usage(
            TimePeriod={
                'Start': self.start_date,
                'End': self.end_date
            },
            Granularity='DAILY',
            Metrics=['UnblendedCost', 'UsageQuantity'],
            GroupBy=[
                {'Type': 'DIMENSION', 'Key': 'SERVICE'},
                {'Type': 'DIMENSION', 'Key': 'INSTANCE_TYPE'},
                {'Type': 'DIMENSION', 'Key': 'REGION'}
            ]
        )
        return self.process_data(response)
    
    def analyze_stability(self, data):
        """分析使用稳定性"""
        df = pd.DataFrame(data)
        
        stability_metrics = {
            'baseline': df['usage'].quantile(0.2),  # P20 基线
            'average': df['usage'].mean(),
            'peak': df['usage'].max(),
            'std_dev': df['usage'].std(),
            'cv': df['usage'].std() / df['usage'].mean()  # 变异系数
        }
        
        # 稳定性评分 (0-100)
        if stability_metrics['cv'] < 0.1:
            stability_score = 95  # 非常稳定
        elif stability_metrics['cv'] < 0.2:
            stability_score = 80  # 稳定
        elif stability_metrics['cv'] < 0.3:
            stability_score = 60  # 中等
        else:
            stability_score = 40  # 不稳定
        
        stability_metrics['score'] = stability_score
        return stability_metrics

1.3 团队准备

关键利益相关者清单

第二部分：使用分析评估

2.1 使用模式分析清单

EC2 实例分析

• 使用率分析

  • CPU 利用率 > 20% 的时间占比
  • 内存利用率 > 30% 的时间占比
  • 网络利用率分析
  • 存储 IOPS 使用情况

• 运行时间分析

  • 24/7 运行的实例清单
  • 定时运行的实例及时间段
  • 临时/短期实例占比
  • 开发/测试环境运行模式

• 实例族分析

  • 当前使用的实例族分布
  • 新一代实例的兼容性
  • 实例族升级计划
  • ARM (Graviton) 迁移可能性

2.2 稳定性评分矩阵

def calculate_stability_score(usage_data):
    """
    计算工作负载稳定性评分
    返回：0-100 的稳定性分数
    """
    scores = {
        'time_consistency': 0,    # 时间一致性
        'volume_stability': 0,    # 用量稳定性
        'pattern_predictability': 0,  # 模式可预测性
        'business_certainty': 0   # 业务确定性
    }
    
    # 时间一致性评分（40分）
    running_hours = calculate_running_hours(usage_data)
    if running_hours >= 720:  # 24/7 运行
        scores['time_consistency'] = 40
    elif running_hours >= 540:  # 75% 时间运行
        scores['time_consistency'] = 30
    elif running_hours >= 360:  # 50% 时间运行
        scores['time_consistency'] = 20
    else:
        scores['time_consistency'] = 10
    
    # 用量稳定性评分（30分）
    cv = calculate_coefficient_variation(usage_data)
    if cv < 0.1:
        scores['volume_stability'] = 30
    elif cv < 0.2:
        scores['volume_stability'] = 20
    elif cv < 0.3:
        scores['volume_stability'] = 10
    else:
        scores['volume_stability'] = 5
    
    # 模式可预测性评分（20分）
    pattern_score = analyze_pattern(usage_data)
    scores['pattern_predictability'] = pattern_score * 20
    
    # 业务确定性评分（10分）
    scores['business_certainty'] = get_business_certainty_score()
    
    total_score = sum(scores.values())
    
    return {
        'total_score': total_score,
        'details': scores,
        'recommendation': get_recommendation(total_score)
    }


def get_recommendation(score):
    if score >= 80:
        return "强烈推荐购买 3 年 RI/SP"
    elif score >= 60:
        return "推荐购买 1 年 RI/SP"
    elif score >= 40:
        return "谨慎购买，建议部分覆盖"
    else:
        return "不推荐购买，使用按需或 Spot"

2.3 服务覆盖分析

多服务使用分布表

第三部分：财务分析

3.1 ROI 计算模板

class RISPFinancialAnalyzer:
    def __init__(self):
        self.discount_rates = {
            'ec2_ri_1y_all_upfront': 0.42,
            'ec2_ri_3y_all_upfront': 0.62,
            'compute_sp_1y_all_upfront': 0.52,
            'compute_sp_3y_all_upfront': 0.66,
            'ec2_sp_1y_all_upfront': 0.58,
            'ec2_sp_3y_all_upfront': 0.72
        }
    
    def calculate_roi(self, monthly_usage, purchase_type, commitment_amount):
        """
        计算投资回报率
        """
        discount_rate = self.discount_rates.get(purchase_type, 0)
        
        # 计算节省额
        monthly_on_demand = monthly_usage
        monthly_with_discount = monthly_usage * (1 - discount_rate)
        monthly_savings = monthly_on_demand - monthly_with_discount
        
        # 计算回本时间
        if 'all_upfront' in purchase_type:
            upfront_cost = commitment_amount * 12 if '1y' in purchase_type else commitment_amount * 36
            payback_months = upfront_cost / monthly_savings
        else:
            payback_months = 0  # 无预付或部分预付另算
        
        # 计算总 ROI
        term_months = 12 if '1y' in purchase_type else 36
        total_savings = monthly_savings * term_months
        total_investment = commitment_amount * term_months
        roi_percentage = (total_savings / total_investment) * 100
        
        return {
            'monthly_savings': monthly_savings,
            'payback_months': payback_months,
            'total_savings': total_savings,
            'roi_percentage': roi_percentage,
            'break_even_date': self.calculate_break_even_date(payback_months)
        }
    
    def sensitivity_analysis(self, base_usage, scenarios):
        """
        敏感性分析：不同使用场景下的 ROI
        """
        results = []
        
        for scenario in scenarios:
            adjusted_usage = base_usage * scenario['usage_factor']
            roi = self.calculate_roi(
                adjusted_usage,
                scenario['purchase_type'],
                scenario['commitment']
            )
            
            results.append({
                'scenario': scenario['name'],
                'usage_change': f"{(scenario['usage_factor']-1)*100:+.0f}%",
                'roi': roi['roi_percentage'],
                'risk_level': self.assess_risk(roi['roi_percentage'])
            })
        
        return pd.DataFrame(results)

3.2 成本对比分析表

三年期总成本对比（示例：m5.xlarge）

3.3 现金流影响分析

支付方式对现金流的影响：


全预付（All Upfront）：
- 优点：最大折扣，简单管理
- 缺点：大量前期现金支出
- 适合：现金充裕的企业

月度	现金流
0	-$43,200 (一次性)
1-36	$0

部分预付（Partial Upfront）：
- 优点：平衡折扣和现金流
- 缺点：折扣略低
- 适合：大多数企业

月度	现金流
0	-$21,600 (预付50%)
1-36	-$600/月

无预付（No Upfront）：
- 优点：无前期投入
- 缺点：折扣最低
- 适合：现金流紧张的企业

月度	现金流
0	$0
1-36	-$1,200/月

第四部分：风险评估

4.1 风险评估矩阵

4.2 风险量化模型

def calculate_risk_adjusted_roi(base_roi, risk_factors):
    """
    计算风险调整后的 ROI
    """
    # 风险权重
    weights = {
        'technical_risk': 0.3,
        'business_risk': 0.4,
        'financial_risk': 0.3
    }
    
    # 计算综合风险分数（0-1）
    total_risk = sum(
        risk_factors[risk] * weights[risk] 
        for risk in weights
    )
    
    # 风险调整
    risk_adjusted_roi = base_roi * (1 - total_risk * 0.5)
    
    # 风险等级判定
    if total_risk < 0.3:
        risk_level = "低风险"
        action = "推荐购买"
    elif total_risk < 0.6:
        risk_level = "中风险"
        action = "谨慎购买"
    else:
        risk_level = "高风险"
        action = "不推荐购买"
    
    return {
        'base_roi': base_roi,
        'risk_score': total_risk,
        'adjusted_roi': risk_adjusted_roi,
        'risk_level': risk_level,
        'recommendation': action
    }

4.3 情景分析

不同业务场景下的最优策略

# 情景定义
scenarios = {
    "稳定增长": {
        "growth_rate": 0.2,  # 20% 年增长
        "certainty": 0.8,    # 80% 确定性
        "recommendation": "3年 EC2 Instance SP，70% 覆盖"
    },
    "快速扩张": {
        "growth_rate": 0.5,  # 50% 年增长
        "certainty": 0.6,
        "recommendation": "1年 Compute SP，50% 覆盖"
    },
    "业务转型": {
        "growth_rate": 0.0,
        "certainty": 0.3,
        "recommendation": "短期 SP + Spot 组合"
    },
    "成本优化": {
        "growth_rate": -0.1,  # 缩减 10%
        "certainty": 0.7,
        "recommendation": "优化现有资源，暂缓新购"
    }
}


# 决策树
def recommend_strategy(current_usage, business_scenario):
    scenario = scenarios[business_scenario]
    
    if scenario["certainty"] > 0.7:
        if scenario["growth_rate"] > 0.3:
            return "激进策略：3年 SP，80% 覆盖"
        else:
            return "稳健策略：3年 SP，60% 覆盖"
    else:
        if scenario["growth_rate"] > 0:
            return "保守策略：1年 SP，40% 覆盖"
        else:
            return "观望策略：维持现状"

第五部分：购买决策框架

5.1 决策评分卡

class PurchaseDecisionScorecard:
    def __init__(self):
        self.criteria = {
            '使用稳定性': {'weight': 25, 'score': 0},
            '财务收益': {'weight': 25, 'score': 0},
            '业务确定性': {'weight': 20, 'score': 0},
            '技术匹配度': {'weight': 15, 'score': 0},
            '风险可控性': {'weight': 15, 'score': 0}
        }
    
    def evaluate(self, metrics):
        # 使用稳定性评分
        if metrics['usage_cv'] < 0.1:
            self.criteria['使用稳定性']['score'] = 100
        elif metrics['usage_cv'] < 0.2:
            self.criteria['使用稳定性']['score'] = 75
        elif metrics['usage_cv'] < 0.3:
            self.criteria['使用稳定性']['score'] = 50
        else:
            self.criteria['使用稳定性']['score'] = 25
        
        # 财务收益评分
        if metrics['roi'] > 150:
            self.criteria['财务收益']['score'] = 100
        elif metrics['roi'] > 100:
            self.criteria['财务收益']['score'] = 75
        elif metrics['roi'] > 50:
            self.criteria['财务收益']['score'] = 50
        else:
            self.criteria['财务收益']['score'] = 25
        
        # 计算总分
        total_score = sum(
            c['weight'] * c['score'] / 100 
            for c in self.criteria.values()
        )
        
        return {
            'total_score': total_score,
            'decision': self.make_decision(total_score),
            'details': self.criteria
        }
    
    def make_decision(self, score):
        if score >= 80:
            return "强烈推荐：立即购买"
        elif score >= 60:
            return "推荐：计划购买"
        elif score >= 40:
            return "考虑：深入评估"
        else:
            return "不推荐：暂缓购买"

5.2 购买策略选择树

flowchart TD
    A[开始评估] --> B{月账单 > $50k?}
    B -->|是| C{使用稳定性 > 70%?}
    B -->|否| D[小规模策略]
    
    C -->|是| E{现金流充裕?}
    C -->|否| F[中等稳定策略]
    
    E -->|是| G[3年全预付 EC2 SP]
    E -->|否| H[3年部分预付 Compute SP]
    
    F --> I{技术栈稳定?}
    I -->|是| J[1年 EC2 SP]
    I -->|否| K[1年 Compute SP]
    
    D --> L{使用可预测?}
    L -->|是| M[1年 Compute SP 部分覆盖]
    L -->|否| N[保持按需 + Spot]

5.3 分阶段购买策略

渐进式购买计划模板

第六部分：执行清单

6.1 购买前最终检查清单

数据验证

• 使用数据涵盖至少 3 个月
• 排除了异常峰值和一次性事件
• 考虑了季节性因素
• 验证了未来业务预测

财务审批

• ROI 计算已验证
• 现金流影响已评估
• 预算已批准
• 财务团队已签字

技术确认

• 实例类型不会被淘汰
• 区域选择已确定
• 操作系统兼容性确认
• 架构演进计划已考虑

风险控制

• 风险评估已完成
• 缓解措施已制定
• 退出策略已准备
• 应急预案已制定

6.2 购买执行步骤

def execute_purchase(purchase_plan):
    """
    执行 RI/SP 购买流程
    """
    steps = [
        {
            'step': 1,
            'action': '登录 AWS 管理账户',
            'responsible': 'FinOps 团队',
            'checkpoint': '确认账户权限'
        },
        {
            'step': 2,
            'action': '进入 Cost Management Console',
            'responsible': 'FinOps 团队',
            'checkpoint': '查看当前覆盖率'
        },
        {
            'step': 3,
            'action': '选择购买类型（RI/SP）',
            'responsible': 'FinOps 团队',
            'checkpoint': '确认折扣率'
        },
        {
            'step': 4,
            'action': '配置购买参数',
            'details': {
                'type': purchase_plan['type'],
                'term': purchase_plan['term'],
                'payment': purchase_plan['payment'],
                'amount': purchase_plan['amount']
            }
        },
        {
            'step': 5,
            'action': '审核订单详情',
            'checkpoint': '金额、期限、覆盖范围'
        },
        {
            'step': 6,
            'action': '提交购买',
            'responsible': '授权审批人',
            'checkpoint': '保存订单确认'
        },
        {
            'step': 7,
            'action': '验证生效',
            'responsible': 'FinOps 团队',
            'checkpoint': '24小时内确认应用'
        }
    ]
    
    return steps

6.3 购买后立即行动

第七部分：监控与优化

7.1 监控指标体系

class RISPMonitor:
    def __init__(self):
        self.kpis = {
            'utilization': {
                'target': 95,
                'alert_threshold': 90,
                'action_threshold': 85
            },
            'coverage': {
                'target': 70,
                'alert_threshold': 60,
                'action_threshold': 50
            },
            'waste': {
                'target': 5,
                'alert_threshold': 10,
                'action_threshold': 15
            }
        }
    
    def create_dashboard(self):
        """创建监控仪表板配置"""
        return {
            'widgets': [
                {
                    'type': 'line',
                    'title': 'RI/SP 利用率趋势',
                    'metrics': ['daily_utilization', 'weekly_avg', 'monthly_avg'],
                    'period': '30_days'
                },
                {
                    'type': 'gauge',
                    'title': '当前利用率',
                    'metric': 'current_utilization',
                    'thresholds': [85, 90, 95]
                },
                {
                    'type': 'bar',
                    'title': '未覆盖支出',
                    'metrics': ['ec2_uncovered', 'rds_uncovered', 'other_uncovered'],
                    'period': 'current_month'
                },
                {
                    'type': 'number',
                    'title': '本月节省',
                    'metric': 'monthly_savings',
                    'comparison': 'month_over_month'
                }
            ]
        }
    
    def generate_alerts(self):
        """生成告警规则"""
        alerts = []
        
        for kpi, thresholds in self.kpis.items():
            alerts.append({
                'name': f'RISP_{kpi}_Alert',
                'metric': kpi,
                'threshold': thresholds['alert_threshold'],
                'comparison': 'LessThanThreshold' if kpi != 'waste' else 'GreaterThanThreshold',
                'actions': ['send_email', 'create_ticket']
            })
        
        return alerts

7.2 优化行动矩阵

7.3 月度复盘模板

# RI/SP 月度复盘报告


## 1. 关键指标
- 平均利用率：____%
- 覆盖率：____%
- 本月节省：$_____
- 累计节省：$_____
- ROI：____%

## 2. 问题与改进



问题
影响
根因
改进措施
负责人
期限






| | | | | | |


## 3. 下月计划
- [ ] 优化行动项
- [ ] 新购买计划
- [ ] 调整策略

## 4. 经验教训
- 成功经验：
- 失败教训：
- 最佳实践：

第八部分：高级优化策略

8.1 组合优化模型

from scipy.optimize import linprog
import numpy as np


class RISPPortfolioOptimizer:
    """
    RI/SP 组合优化器
    使用线性规划找到最优购买组合
    """
    
    def optimize_portfolio(self, usage_forecast, constraints):
        """
        优化 RI/SP 购买组合
        """
        # 决策变量：各类 RI/SP 的购买量
        options = [
            {'type': 'EC2_RI_1Y', 'discount': 0.42, 'flexibility': 0.3},
            {'type': 'EC2_RI_3Y', 'discount': 0.62, 'flexibility': 0.1},
            {'type': 'Compute_SP_1Y', 'discount': 0.52, 'flexibility': 0.8},
            {'type': 'Compute_SP_3Y', 'discount': 0.66, 'flexibility': 0.7},
            {'type': 'EC2_SP_1Y', 'discount': 0.58, 'flexibility': 0.5},
            {'type': 'EC2_SP_3Y', 'discount': 0.72, 'flexibility': 0.4}
        ]
        
        # 目标函数：最大化总节省
        c = [-opt['discount'] * usage_forecast for opt in options]
        
        # 约束条件
        A_ub = []
        b_ub = []
        
        # 约束1：总覆盖不超过预测使用量
        A_ub.append([1] * len(options))
        b_ub.append(usage_forecast)
        
        # 约束2：预算限制
        if 'budget' in constraints:
            A_ub.append([usage_forecast * (1-opt['discount']) for opt in options])
            b_ub.append(constraints['budget'])
        
        # 约束3：灵活性要求
        if 'min_flexibility' in constraints:
            # 加权平均灵活性 >= 最小要求
            flexibility_weights = [opt['flexibility'] for opt in options]
            # 这是一个非线性约束，需要迭代求解
        
        # 求解
        result = linprog(c, A_ub=A_ub, b_ub=b_ub, bounds=(0, None), method='highs')
        
        # 返回最优组合
        optimal_portfolio = {}
        for i, opt in enumerate(options):
            if result.x[i] > 0:
                optimal_portfolio[opt['type']] = {
                    'amount': result.x[i],
                    'savings': result.x[i] * opt['discount'] * usage_forecast
                }
        
        return optimal_portfolio

8.2 动态调整策略

季度调整决策树

def quarterly_adjustment_decision(current_portfolio, market_conditions):
    """
    季度 RI/SP 组合调整决策
    """
    adjustments = []
    
    # 检查利用率
    for item in current_portfolio:
        if item['utilization'] < 0.85:
            # 利用率低，需要调整
            if item['type'].endswith('_RI'):
                if 'Convertible' in item['type']:
                    adjustments.append({
                        'action': 'CONVERT',
                        'item': item,
                        'target': 'smaller_instance_type'
                    })
                else:
                    adjustments.append({
                        'action': 'INCREASE_WORKLOAD',
                        'item': item
                    })
            else:  # SP
                adjustments.append({
                    'action': 'MIGRATE_WORKLOAD',
                    'item': item,
                    'target': 'increase_sp_eligible_usage'
                })
        
        elif item['utilization'] > 0.98:
            # 利用率过高，考虑增购
            remaining_term = item['remaining_months']
            if remaining_term < 6:
                adjustments.append({
                    'action': 'PREPARE_RENEWAL',
                    'item': item
                })
            else:
                adjustments.append({
                    'action': 'ADDITIONAL_PURCHASE',
                    'amount': item['uncovered_usage'] * 0.7
                })
    
    # 市场条件调整
    if market_conditions['new_instance_generation']:
        adjustments.append({
            'action': 'EVALUATE_UPGRADE',
            'reason': 'New generation offers better price/performance'
        })
    
    return adjustments

8.3 自动化执行框架

import boto3
from datetime import datetime, timedelta


class RISPAutomationFramework:
    def __init__(self):
        self.ce_client = boto3.client('ce')
        self.sns_client = boto3.client('sns')
        self.dynamodb = boto3.resource('dynamodb')
        self.table = self.dynamodb.Table('risp-automation-state')
    
    def automated_purchase_workflow(self):
        """
        自动化购买工作流
        """
        # Step 1: 数据收集
        usage_data = self.collect_usage_data()
        
        # Step 2: 分析评估
        assessment = self.assess_purchase_opportunity(usage_data)
        
        # Step 3: 决策
        if assessment['score'] > 80:
            purchase_plan = self.generate_purchase_plan(assessment)
            
            # Step 4: 审批流程
            approval = self.request_approval(purchase_plan)
            
            if approval['status'] == 'approved':
                # Step 5: 执行购买
                result = self.execute_purchase(purchase_plan)
                
                # Step 6: 验证
                self.verify_purchase(result)
                
                # Step 7: 通知
                self.send_notifications(result)
        
        # Step 8: 记录
        self.log_workflow_execution(assessment)
    
    def setup_automated_monitoring(self):
        """
        设置自动化监控
        """
        # CloudWatch Events 规则
        rules = [
            {
                'name': 'risp-daily-check',
                'schedule': 'rate(1 day)',
                'target': 'lambda:risp-utilization-checker'
            },
            {
                'name': 'risp-weekly-report',
                'schedule': 'cron(0 9 ? * MON *)',
                'target': 'lambda:risp-weekly-reporter'
            },
            {
                'name': 'risp-monthly-optimization',
                'schedule': 'cron(0 10 1 * ? *)',
                'target': 'lambda:risp-optimizer'
            }
        ]
        
        return rules

第九部分：可打印模板

9.1 一页纸评估表

┌─────────────────────────────────────────────────────────────────┐
│              RI/SP 快速评估表 - [日期：_______]                 │
├─────────────────────────────────────────────────────────────────┤
│ 基础信息                                                        │
│ ├─ 当前月度支出：$________    目标节省：____%                   │
│ ├─ 评估服务：□ EC2  □ RDS  □ Lambda  □ Fargate  □ 其他        │
│ └─ 评估期限：□ 1年  □ 3年                                      │
├─────────────────────────────────────────────────────────────────┤
│ 稳定性评分（满分40）                                            │
│ ├─ 运行时间：□ 24/7(10) □ 18/7(7) □ 12/7(5) □ <12/7(2)       │
│ ├─ 使用波动：□ <10%(10) □ <20%(7) □ <30%(5) □ >30%(2)        │
│ ├─ 历史数据：□ >6月(10) □ 3-6月(7) □ 1-3月(5) □ <1月(2)      │
│ └─ 未来确定：□ 高(10) □ 中(7) □ 低(5) □ 不确定(2)            │
├─────────────────────────────────────────────────────────────────┤
│ 财务评估（满分30）                                              │
│ ├─ ROI预期：□ >150%(10) □ 100-150%(7) □ 50-100%(5) □ <50%(2) │
│ ├─ 回本时间：□ <6月(10) □ 6-12月(7) □ 12-18月(5) □ >18月(2)  │
│ └─ 现金流：□ 充裕(10) □ 正常(7) □ 紧张(5) □ 困难(2)          │
├─────────────────────────────────────────────────────────────────┤
│ 风险评估（满分30）                                              │
│ ├─ 技术风险：□ 低(10) □ 中(7) □ 高(5) □ 很高(2)              │
│ ├─ 业务风险：□ 低(10) □ 中(7) □ 高(5) □ 很高(2)              │
│ └─ 退出成本：□ 低(10) □ 中(7) □ 高(5) □ 很高(2)              │
├─────────────────────────────────────────────────────────────────┤
│ 总分：____/100  决策：□ 立即购买 □ 计划购买 □ 继续评估 □ 放弃│
│ 审批人：____________  日期：____________                        │
└─────────────────────────────────────────────────────────────────┘

9.2 执行检查清单（可打印）

□ RI/SP 购买执行检查清单


购买信息：
类型：________________  金额：$________________
期限：________________  支付：________________

── 购买前检查 ──
□ 1. 使用数据已验证（至少3个月）
□ 2. ROI 计算已确认（>100%）
□ 3. 预算已批准
□ 4. 技术团队已确认
□ 5. 风险评估已完成

── 购买执行 ──
□ 6. 登录正确的 AWS 账户
□ 7. 选择正确的购买类型
□ 8. 配置正确的参数
□ 9. 金额核对无误
□ 10. 获得最终批准

── 购买后验证 ──
□ 11. 购买确认邮件已收到
□ 12. 24小时内折扣已生效
□ 13. 监控告警已设置
□ 14. 团队通知已发送
□ 15. 文档已更新

签字确认：
执行人：____________  日期：____________
审核人：____________  日期：____________

第十部分：最佳实践总结

10.1 成功案例模式

10.2 常见陷阱避免

# 陷阱检测器
def detect_common_pitfalls(purchase_plan):
    pitfalls = []
    
    # 陷阱1：过度承诺
    if purchase_plan['coverage'] > 0.8:
        pitfalls.append({
            'type': '过度承诺',
            'risk': '高',
            'mitigation': '降低覆盖率到 60-70%'
        })
    
    # 陷阱2：忽视新一代实例
    if 'previous_generation' in purchase_plan['instance_type']:
        pitfalls.append({
            'type': '使用旧实例',
            'risk': '中',
            'mitigation': '迁移到新一代实例'
        })
    
    # 陷阱3：单一策略
    if len(purchase_plan['types']) == 1:
        pitfalls.append({
            'type': '缺乏多样性',
            'risk': '中',
            'mitigation': '混合 RI 和 SP'
        })
    
    # 陷阱4：忽视 Spot
    if purchase_plan['spot_percentage'] == 0:
        pitfalls.append({
            'type': '未使用 Spot',
            'risk': '低',
            'mitigation': '评估 Spot 可行性'
        })
    
    return pitfalls

10.3 持续改进路线图

flowchart LR
    A[Level 1: 基础] --> B[Level 2: 标准化]
    B --> C[Level 3: 优化]
    C --> D[Level 4: 自动化]
    D --> E[Level 5: 智能化]
    
    A1[手动购买<br/>事后分析] --> B1[流程化购买<br/>定期复盘]
    B1 --> C1[数据驱动<br/>组合优化]
    C1 --> D1[自动化决策<br/>动态调整]
    D1 --> E1[AI 预测<br/>自主优化]

总结与行动建议

立即行动（今天）

1. 下载并打印评估表格
2. 收集最近 3 个月使用数据
3. 完成初步稳定性评分

短期行动（本周）

1. 完成完整的 ROI 分析
2. 与相关团队沟通确认
3. 制定初步购买计划

中期行动（本月）

1. 完成风险评估
2. 获得预算批准
3. 执行首次购买

长期行动（季度）

1. 建立监控体系
2. 优化购买组合
3. 分享最佳实践

记住：RI/SP 优化是马拉松，不是短跑。从小规模开始，逐步优化，持续改进。

下载资源：

• Excel 评估模板
• PDF 打印版清单
• 自动化脚本集

相关阅读：

• Savings Plans 按服务覆盖实战
• 预留实例 Standard vs Convertible
• AWS 成本优化大全