第268集：云成本优化

教学目标

  • 理解云成本的构成和影响因素
  • 掌握成本分析和监控方法
  • 熟悉资源优化和架构优化
  • 学习成本预测和预算管理
  • 能够实施全面的成本优化策略

核心知识点

1. 云成本概述

1.1 云成本构成

成本类型 描述 优化策略
计算成本 实例、容器、函数计算 合理选择实例类型、自动扩缩容
存储成本 对象存储、块存储、文件存储 生命周期策略、存储类别选择
网络成本 数据传输、CDN、VPN 优化数据传输、使用CDN
数据库成本 托管数据库、缓存服务 合理配置、读写分离
服务成本 监控、日志、安全服务 评估必要性、选择合适层级

1.2 成本优化原则

  • 按需使用：只使用需要的资源
  • 预留实例：长期使用预留实例降低成本
  • 自动扩缩容：根据负载自动调整资源
  • 资源复用：共享资源提高利用率
  • 定期审查：定期检查和优化资源使用

2. AWS成本优化

2.1 成本分析

# 启用成本和用量报告
aws cur put-report-definition \
  --report-name monthly-cost-report \
  --time-unit MONTHLY \
  --format CSV \
  --compression ZIP \
  --s3-bucket my-cost-bucket \
  --s3-prefix cost-reports \
  --s3-region us-east-1

# 查询成本 Explorer
aws ce get-cost-and-usage \
  --time-period Start=2024-01-01,End=2024-01-31 \
  --granularity MONTHLY \
  --metrics BlendedCost \
  --group-by Type

# 查询服务成本
aws ce get-cost-and-usage \
  --time-period Start=2024-01-01,End=2024-01-31 \
  --granularity MONTHLY \
  --metrics BlendedCost \
  --group-by SERVICE

# 查询标签成本
aws ce get-cost-and-usage \
  --time-period Start=2024-01-01,End=2024-01-31 \
  --granularity MONTHLY \
  --metrics BlendedCost \
  --group-by TAG

# 获取成本预测
aws ce get-cost-forecast \
  --time-period Start=2024-02-01,End=2024-03-01 \
  --metric BLENDED_COST \
  --granularity MONTHLY

2.2 预留实例

# 购买预留实例
aws ec2 purchase-reserved-instances-offering \
  --instance-count 1 \
  --instance-type t2.micro \
  --offering-class standard \
  --offering-type partial-upfront \
  --usage-class default

# 查看预留实例报价
aws ec2 describe-reserved-instances-offerings \
  --instance-type t2.micro \
  --offering-class standard \
  --product-description Linux/UNIX

# 查看预留实例
aws ec2 describe-reserved-instances

# 取消预留实例
aws ec2 cancel-reserved-instances-offering \
  --reserved-instances-offering-id 12345678-1234-1234-1234-123456789012

2.3 Spot实例

# 创建Spot实例请求
SPOT_REQUEST_ID=$(aws ec2 request-spot-instances \
  --spot-price 0.003 \
  --instance-count 1 \
  --type one-time \
  --launch-specification file://launch-spec.json \
  --query 'SpotInstanceRequests[0].SpotInstanceRequestId' \
  --output text)

echo "Spot Request ID: $SPOT_REQUEST_ID"

# launch-spec.json
cat > launch-spec.json << 'EOF'
{
  "ImageId": "ami-0c55b159cbfafe1f0",
  "InstanceType": "t2.micro",
  "KeyName": "my-key-pair",
  "SecurityGroupIds": ["sg-12345678"]
}
EOF

# 查看Spot请求状态
aws ec2 describe-spot-instance-requests \
  --spot-instance-request-ids $SPOT_REQUEST_ID

# 取消Spot请求
aws ec2 cancel-spot-instance-requests \
  --spot-instance-request-ids $SPOT_REQUEST_ID

# 创建Spot Fleet
aws ec2 request-spot-fleet \
  --spot-fleet-request-config file://fleet-config.json

# fleet-config.json
cat > fleet-config.json << 'EOF'
{
  "IamFleetRole": "arn:aws:iam::123456789012:role/fleet-role",
  "SpotOptions": {
    "AllocationStrategy": "lowest-price"
  },
  "TargetCapacitySpecification": {
    "TotalTargetCapacity": 10,
    "DefaultTargetCapacityType": "on-demand",
    "SpotTargetCapacity": 8
  },
  "LaunchSpecifications": [
    {
      "InstanceType": "t2.micro",
      "ImageId": "ami-0c55b159cbfafe1f0",
      "KeyName": "my-key-pair",
      "SubnetId": "subnet-12345678"
    }
  ]
}
EOF

3. Azure成本优化

3.1 成本分析

# 查看成本管理
az consumption usage list \
  --start-date 2024-01-01 \
  --end-date 2024-01-31

# 查看预算
az consumption budget list

# 创建预算
az consumption budget create \
  --name monthly-budget \
  --category cost \
  --amount 1000 \
  --time-grain Monthly \
  --time-period StartDate=2024-01-01,EndDate=2024-12-31

# 查看预留实例
az reservations list

# 购买预留实例
az reservations purchase \
  --reservation-order-id /providers/Microsoft.Capacity/reservationOrders/12345678-1234-1234-1234-123456789012

3.2 Azure优惠

# 查看优惠
az reservations list \
  --resource-type VirtualMachines

# 购买优惠
az reservations purchase \
  --reservation-order-id /providers/Microsoft.Capacity/reservationOrders/12345678-1234-1234-1234-123456789012 \
  --sku Standard_B1s \
  --location eastus \
  --quantity 1 \
  --billing-plan Monthly \
  --term P1Y

# 查看优惠使用情况
az reservations show \
  --reservation-id /providers/Microsoft.Capacity/reservationOrders/12345678-1234-1234-1234-123456789012

4. GCP成本优化

4.1 成本分析

# 查看成本数据
gcloud billing projects describe my-project

# 查看成本明细
gcloud billing accounts describe 123456789012 \
  --format json

# 创建预算
gcloud billing budgets create \
  --billing-account 123456789012 \
  --display-name "Monthly Budget" \
  --budget-amount 1000USD \
  --threshold-rule percent=90,spend-basis=current-spend

# 查看预算
gcloud billing budgets list \
  --billing-account 123456789012

4.2 预留实例

# 购买预留实例
gcloud compute reservations create \
  --machine-type n1-standard-1 \
  --zone us-central1-a \
  --commitment-term 1-year \
  --count 1

# 查看预留实例
gcloud compute reservations list

# 删除预留实例
gcloud compute reservations delete \
  --reservation-name my-reservation \
  --zone us-central1-a

5. 资源优化

5.1 实例优化

# 使用AWS Compute Optimizer
aws compute-optimizer get-recommendations \
  --account-ids 123456789012 \
  --service-code ec2

# 查看优化建议
aws compute-optimizer get-recommendation-summaries \
  --account-ids 123456789012 \
  --service-code ec2

# 导出优化报告
aws compute-optimizer export-lambda-function-recommendations \
  --account-ids 123456789012 \
  --s3-bucket my-optimization-bucket \
  --s3-key-prefix optimization-reports

5.2 存储优化

# 配置S3生命周期策略
cat > lifecycle-policy.json << 'EOF'
{
  "Rules": [
    {
      "ID": "MoveToIA",
      "Status": "Enabled",
      "Prefix": "",
      "Transition": {
        "Days": 30,
        "StorageClass": "STANDARD_IA"
      }
    },
    {
      "ID": "MoveToGlacier",
      "Status": "Enabled",
      "Prefix": "",
      "Transition": {
        "Days": 90,
        "StorageClass": "GLACIER"
      }
    },
    {
      "ID": "DeleteOldVersions",
      "Status": "Enabled",
      "Prefix": "",
      "NoncurrentVersionExpiration": {
        "NoncurrentDays": 30
      }
    }
  ]
}
EOF

aws s3api put-bucket-lifecycle-configuration \
  --bucket my-bucket \
  --lifecycle-configuration file://lifecycle-policy.json

# 配置EBS生命周期策略
aws ec2 modify-volume-attribute \
  --volume-id vol-1234567890abcdef0 \
  --auto-enable-io {Value=true}

# 删除未使用的快照
aws ec2 describe-snapshots \
  --owner-ids 123456789012 \
  --query 'Snapshots[?StartTime<`2024-01-01`].SnapshotId' \
  --output text | xargs -I {} aws ec2 delete-snapshot --snapshot-id {}

6. 架构优化

6.1 无服务器架构

# 创建Lambda函数
aws lambda create-function \
  --function-name cost-optimized-function \
  --runtime python3.9 \
  --role arn:aws:iam::123456789012:role/lambda-role \
  --handler index.handler \
  --code S3Bucket=my-bucket,S3Key=function.zip \
  --memory-size 128 \
  --timeout 30

# 配置Lambda自动扩缩容
aws lambda put-provisioned-concurrency-config \
  --function-name cost-optimized-function \
  --provisioned-concurrent-executions 10

# 使用API Gateway
aws apigateway create-rest-api \
  --name cost-optimized-api

# 创建API资源
RESOURCE_ID=$(aws apigateway create-resource \
  --rest-api-id $API_ID \
  --parent-id $ROOT_ID \
  --path-part hello \
  --query 'id' \
  --output text)

# 创建GET方法
aws apigateway put-method \
  --rest-api-id $API_ID \
  --resource-id $RESOURCE_ID \
  --http-method GET \
  --authorization-type NONE

# 集成Lambda函数
aws apigateway put-integration \
  --rest-api-id $API_ID \
  --resource-id $RESOURCE_ID \
  --http-method GET \
  --type AWS_PROXY \
  --integration-http-method POST \
  --integration-uri arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:cost-optimized-function/invocations

# 部署API
aws apigateway create-deployment \
  --rest-api-id $API_ID \
  --stage-name prod

6.2 容器化优化

# 使用Fargate节省成本
aws ecs create-cluster \
  --cluster-name cost-optimized-cluster

# 创建Fargate任务定义
aws ecs register-task-definition \
  --family cost-optimized-task \
  --network-mode awsvpc \
  --requires-compatibilities FARGATE \
  --cpu 256 \
  --memory 512 \
  --container-definitions file://task-definition.json

# task-definition.json
cat > task-definition.json << 'EOF'
[
  {
    "name": "web-app",
    "image": "nginx:latest",
    "essential": true,
    "portMappings": [
      {
        "containerPort": 80,
        "protocol": "tcp"
      }
    ],
    "logConfiguration": {
      "logDriver": "awslogs",
      "options": {
        "awslogs-group": "/ecs/cost-optimized-cluster",
        "awslogs-region": "us-east-1",
        "awslogs-stream-prefix": "web-app"
      }
    }
  }
]
EOF

# 创建Fargate服务
aws ecs create-service \
  --cluster cost-optimized-cluster \
  --service-name web-service \
  --task-definition cost-optimized-task \
  --desired-count 2 \
  --launch-type FARGATE \
  --network-configuration file://network-config.json

# network-config.json
cat > network-config.json << 'EOF'
{
  "awsvpcConfiguration": {
    "subnets": ["subnet-12345678", "subnet-87654321"],
    "securityGroups": ["sg-12345678"],
    "assignPublicIp": "ENABLED"
  }
}
EOF

实用案例分析

案例1：实施全面成本优化

场景描述

为Web应用实施全面的成本优化策略，包括实例优化、存储优化和架构优化。

实施步骤

  1. 实例优化
# 分析当前实例使用情况
aws ec2 describe-instances \
  --query 'Reservations[*].Instances[*].[InstanceId,InstanceType,State.Name,LaunchTime]' \
  --output table

# 使用Compute Optimizer获取优化建议
RECOMMENDATIONS=$(aws compute-optimizer get-recommendations \
  --service-code ec2 \
  --query 'Recommendations[*]' \
  --output json)

echo "$RECOMMENDATIONS" | jq '.[] | {
  instance_arn: .InstanceArn,
  current_instance: .CurrentInstance.Type,
  recommended_instance: .RecommendationOptions[0].InstanceType,
  estimated_savings: .RecommendationOptions[0].EstimatedMonthlySavings
}'

# 实施优化建议
for recommendation in $(echo "$RECOMMENDATIONS" | jq -r '.[].RecommendationOptions[0].InstanceType'); do
  echo "Optimizing instance to: $recommendation"
done
  1. 存储优化
# 分析S3存储使用情况
aws s3 ls --recursive s3://my-bucket/ | awk '{print $3}' | sort -rn | head -20

# 配置智能分层
cat > intelligent-tiering-policy.json << 'EOF'
{
  "Rules": [
    {
      "ID": "IntelligentTiering",
      "Status": "Enabled",
      "Prefix": "",
      "Transition": {
        "Days": 90,
        "StorageClass": "INTELLIGENT_TIERING"
      }
    }
  ]
}
EOF

aws s3api put-bucket-lifecycle-configuration \
  --bucket my-bucket \
  --lifecycle-configuration file://intelligent-tiering-policy.json

# 清理未使用的EBS卷
aws ec2 describe-volumes \
  --query 'Volumes[?State==`available`].[VolumeId,Size]' \
  --output table

# 删除未使用的卷
for volume_id in $(aws ec2 describe-volumes \
  --query 'Volumes[?State==`available`].VolumeId' \
  --output text); do
  echo "Deleting unused volume: $volume_id"
  aws ec2 delete-volume --volume-id $volume_id
done
  1. 架构优化
# 迁移到无服务器架构
# 创建Lambda函数
aws lambda create-function \
  --function-name web-api \
  --runtime python3.9 \
  --role arn:aws:iam::123456789012:role/lambda-role \
  --handler index.handler \
  --code S3Bucket=my-bucket,S3Key=lambda.zip \
  --memory-size 128 \
  --timeout 30

# 配置API Gateway
API_ID=$(aws apigateway create-rest-api \
  --name web-api \
  --query 'id' \
  --output text)

# 创建资源
RESOURCE_ID=$(aws apigateway create-resource \
  --rest-api-id $API_ID \
  --parent-id $ROOT_ID \
  --path-part api \
  --query 'id' \
  --output text)

# 创建方法
aws apigateway put-method \
  --rest-api-id $API_ID \
  --resource-id $RESOURCE_ID \
  --http-method POST \
  --authorization-type NONE

# 集成Lambda
aws apigateway put-integration \
  --rest-api-id $API_ID \
  --resource-id $RESOURCE_ID \
  --http-method POST \
  --type AWS_PROXY \
  --integration-http-method POST \
  --integration-uri arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789012:function:web-api/invocations

# 部署API
aws apigateway create-deployment \
  --rest-api-id $API_ID \
  --stage-name prod

# 启用缓存
aws apigateway update-stage \
  --rest-api-id $API_ID \
  --stage-name prod \
  --patch-operations op=replace,path=/cacheClusterEnabled,value=true

# 配置使用计划
aws apigateway create-usage-plan \
  --name api-usage-plan \
  --description "Usage plan for API"

# 创建API密钥
aws apigateway create-api-key \
  --description "API key for client"

案例2：实施成本监控和告警

场景描述

建立全面的成本监控和告警系统，及时发现成本异常。

实施步骤

  1. 配置成本告警
# 创建成本预算
aws budgets create-budget \
  --account-id 123456789012 \
  --budget '{
    "BudgetName": "MonthlyCostBudget",
    "BudgetLimit": {
      "Amount": "1000",
      "Unit": "USD"
    },
    "TimeUnit": "MONTHLY",
    "TimePeriod": {
      "Start": "2024-01-01",
      "End": "2024-12-31"
    }
  }'

# 配置预算通知
aws budgets notify \
  --account-id 123456789012 \
  --budget-name MonthlyCostBudget \
  --notification '{
    "NotificationType": "ACTUAL",
    "ComparisonOperator": "GREATER_THAN",
    "Threshold": 80
  }' \
  --notification-email-subscribers subscriber@example.com

# 创建CloudWatch成本告警
aws cloudwatch put-metric-alarm \
  --alarm-name cost-alarm \
  --alarm-description "Alert when daily cost exceeds threshold" \
  --metric-name EstimatedCharges \
  --namespace AWS/Billing \
  --statistic Maximum \
  --period 86400 \
  --evaluation-periods 1 \
  --threshold 50 \
  --comparison-operator GreaterThanThreshold \
  --treat-missing-data notBreaching
  1. 实施成本分析
# 创建成本分析脚本
cat > cost-analysis.sh << 'EOF'
#!/bin/bash

# 获取本月成本
CURRENT_COST=$(aws ce get-cost-and-usage \
  --time-period Start=$(date -d "$(date +%Y-%m-01)" +%Y-%m-%d),End=$(date +%Y-%m-%d) \
  --granularity MONTHLY \
  --metrics BlendedCost \
  --query 'ResultsByTime[0].Total.BlendedCost' \
  --output text)

echo "Current month cost: $CURRENT_COST"

# 获取上月成本
LAST_MONTH_START=$(date -d "$(date +%Y-%m-01) -1 month" +%Y-%m-%d)
LAST_MONTH_END=$(date -d "$(date +%Y-%m-01) -1 day" +%Y-%m-%d)

LAST_MONTH_COST=$(aws ce get-cost-and-usage \
  --time-period Start=$LAST_MONTH_START,End=$LAST_MONTH_END \
  --granularity MONTHLY \
  --metrics BlendedCost \
  --query 'ResultsByTime[0].Total.BlendedCost' \
  --output text)

echo "Last month cost: $LAST_MONTH_COST"

# 计算增长率
GROWTH_RATE=$(echo "scale=2; ($CURRENT_COST - $LAST_MONTH_COST) / $LAST_MONTH_COST * 100" | bc)
echo "Growth rate: $GROWTH_RATE%"

# 获取服务成本分解
aws ce get-cost-and-usage \
  --time-period Start=$(date -d "$(date +%Y-%m-01)" +%Y-%m-%d),End=$(date +%Y-%m-%d) \
  --granularity MONTHLY \
  --metrics BlendedCost \
  --group-by SERVICE \
  --query 'ResultsByTime[0].Groups[*].[Keys[0],Metrics.BlendedCost]' \
  --output table
EOF

chmod +x cost-analysis.sh
./cost-analysis.sh
  1. 实施自动化优化
# 创建Lambda函数自动优化
cat > optimizer.py << 'EOF'
import boto3
import json

def lambda_handler(event, context):
    ec2 = boto3.client('ec2')
    
    # 获取所有运行中的实例
    instances = ec2.describe_instances(
        Filters=[{'Name': 'instance-state-name', 'Values': ['running']}]
    )
    
    # 检查CPU使用率
    cloudwatch = boto3.client('cloudwatch')
    
    for reservation in instances['Reservations']:
        for instance in reservation['Instances']:
            instance_id = instance['InstanceId']
            
            # 获取CPU使用率
            cpu_metrics = cloudwatch.get_metric_statistics(
                Namespace='AWS/EC2',
                MetricName='CPUUtilization',
                Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
                StartTime=datetime.datetime.now() - datetime.timedelta(hours=24),
                EndTime=datetime.datetime.now(),
                Period=3600,
                Statistics=['Average']
            )
            
            avg_cpu = sum([dp['Average'] for dp in cpu_metrics['Datapoints']]) / len(cpu_metrics['Datapoints'])
            
            # 如果CPU使用率低于10%，建议停止实例
            if avg_cpu < 10:
                print(f"Instance {instance_id} has low CPU usage: {avg_cpu}%")
                
                # 发送通知
                sns = boto3.client('sns')
                sns.publish(
                    TopicArn='arn:aws:sns:us-east-1:123456789012:cost-alerts',
                    Message=f"Instance {instance_id} has low CPU usage: {avg_cpu}%. Consider stopping it.",
                    Subject='Low CPU Usage Alert'
                )
    
    return {
        'statusCode': 200,
        'body': json.dumps('Optimization check completed')
    }
EOF

# 部署Lambda函数
aws lambda create-function \
  --function-name cost-optimizer \
  --runtime python3.9 \
  --role arn:aws:iam::123456789012:role/lambda-role \
  --handler optimizer.lambda_handler \
  --code S3Bucket=my-bucket,S3Key=optimizer.zip \
  --memory-size 128 \
  --timeout 300

# 配置定时触发
aws events put-rule \
  --name daily-cost-optimization \
  --schedule-expression 'rate(1 day)'

aws lambda add-permission \
  --function-name cost-optimizer \
  --statement-id daily-cost-optimization \
  --action lambda:InvokeFunction \
  --principal events.amazonaws.com \
  --source-arn arn:aws:events:us-east-1:123456789012:rule/daily-cost-optimization

aws events put-targets \
  --rule daily-cost-optimization \
  --targets Id=1,Arn=arn:aws:lambda:us-east-1:123456789012:function:cost-optimizer

课后练习

  1. 基础练习

    • 查询和分析云成本
    • 配置成本预算和告警
    • 实施基本的资源优化

  2. 进阶练习

    • 使用Compute Optimizer优化实例
    • 配置存储生命周期策略
    • 实施无服务器架构

  3. 挑战练习

    • 建立全面的成本优化体系
    • 实施自动化成本监控
    • 设计成本优化策略

  4. 思考问题

    • 如何平衡成本和性能？
    • 如何预测云成本？
    • 如何持续优化云成本？

总结

本集详细介绍了Linux系统中云成本的优化方法，包括成本分析、资源优化、架构优化、成本预测以及成本管理工具等内容。通过本集的学习，您应该能够：

  • 理解云成本的构成和影响因素
  • 掌握成本分析和监控方法
  • 熟悉资源优化和架构优化
  • 学习成本预测和预算管理
  • 能够实施全面的成本优化策略

云成本优化是云基础设施管理的重要组成部分，它帮助企业在保证性能的前提下降低运营成本。在实际项目中，应根据业务需求和资源使用情况建立完善的成本管理体系，并持续监控和优化成本，以确保云资源的高效利用和成本控制。

« 上一篇 云监控与告警 下一篇 » 混合云配置
↑