FinOps & クラウドコスト最適化完全ガイド 2025: AWS/GCP/Azure コスト削減戦略

┌─────────────────────────────────────────────────────┐
│                FinOps ライフサイクル                    │
│                                                       │
│    ┌──────────┐    ┌──────────┐    ┌──────────┐     │
│    │  Inform  │───>│ Optimize │───>│ Operate  │     │
│    │          │    │          │    │          │     │
│    │ 可視性   │    │ 最適化   │    │ ガバナンス│    │
│    │ 確保     │    │ 実行     │    │ 持続     │     │
│    └──────────┘    └──────────┘    └──────────┘     │
│         ^                                |           │
│         └────────────────────────────────┘           │
│                    反復 (Iterate)                     │
└─────────────────────────────────────────────────────┘

Level 1: Crawl（基礎）
├── 基本的なコストレポーティング
├── タギング戦略の策定開始
└── 主要コストドライバーの特定

Level 2: Walk（中級）
├── 部門別コスト配分
├── リザーブドインスタンス導入
├── 自動化されたレポーティング
└── コスト異常検知

Level 3: Run（上級）
├── リアルタイムコスト最適化
├── オートスケーリング最適化
├── ユニットエコノミクスベースの追跡
├── コスト予測と予算管理
└── FinOps文化の完全定着

# クラウド課金モデル比較
On-Demand:
  説明: "使った分だけ支払い。コミットメントなし"
  割引率: "0%（基準価格）"
  長所: "柔軟性、即座に開始/停止"
  短所: "最も高価なオプション"
  適したワークロード: "開発/テスト、短期プロジェクト、不規則なワークロード"

Reserved_Instances:
  説明: "1年または3年のコミットメントで割引"
  割引率: "最大72%（AWS）、最大57%（Azure）"
  長所: "大幅な割引、キャパシティ予約"
  短所: "長期コミットメント、柔軟性不足"
  適したワークロード: "安定したプロダクションワークロード"

Savings_Plans:
  説明: "時間あたりの使用量コミットメントで割引（AWS）"
  割引率: "最大72%"
  長所: "RIより柔軟、インスタンスファミリー/リージョン変更可能"
  短所: "コミットメント必要"
  適したワークロード: "安定しているが変動可能なワークロード"

Spot_Preemptible:
  説明: "余剰容量を大幅割引"
  割引率: "最大90%（AWS）、最大91%（GCP）"
  長所: "最も安価"
  短所: "いつでも中断される可能性"
  適したワークロード: "バッチ処理、CI/CD、耐障害性ワークロード"

AWS                    GCP                     Azure
─────────────────────────────────────────────────────────
On-Demand              On-Demand               Pay-as-you-go
Reserved Instances     Committed Use           Reserved VM Instances
Savings Plans          Flex CUDs               Azure Savings Plan
Spot Instances         Preemptible/Spot VMs    Spot VMs
Cost Explorer          Billing Reports         Cost Management
AWS Budgets            GCP Budgets             Azure Budgets
Compute Optimizer      Recommender             Azure Advisor

# 必須タグスキーマ例
mandatory_tags:
  - key: "Environment"
    values: ["production", "staging", "development", "sandbox"]
    description: "リソースが属する環境"

  - key: "Team"
    values: ["platform", "backend", "data", "ml", "frontend"]
    description: "リソースを所有するチーム"

  - key: "Service"
    values: ["user-api", "payment", "notification", "analytics"]
    description: "リソースがサポートするサービス"

  - key: "CostCenter"
    values: ["CC-1001", "CC-1002", "CC-2001"]
    description: "コストセンターコード"

  - key: "ManagedBy"
    values: ["terraform", "cloudformation", "manual", "pulumi"]
    description: "リソース管理ツール"

# AWS Configルールで非準拠リソースを検出
# config_rule_required_tags.py

import json
import boto3

REQUIRED_TAGS = ['Environment', 'Team', 'Service', 'CostCenter']

def lambda_handler(event, context):
    """AWS Configルール: 必須タグチェック"""
    config = boto3.client('config')
    
    configuration_item = json.loads(
        event['invokingEvent']
    )['configurationItem']
    
    resource_tags = configuration_item.get('tags', {})
    missing_tags = [
        tag for tag in REQUIRED_TAGS
        if tag not in resource_tags
    ]
    
    compliance_type = (
        'NON_COMPLIANT' if missing_tags else 'COMPLIANT'
    )
    annotation = (
        f"Missing tags: {', '.join(missing_tags)}"
        if missing_tags else "All required tags present"
    )
    
    config.put_evaluations(
        Evaluations=[{
            'ComplianceResourceType': configuration_item['resourceType'],
            'ComplianceResourceId': configuration_item['resourceId'],
            'ComplianceType': compliance_type,
            'Annotation': annotation,
            'OrderingTimestamp': configuration_item['configurationItemCaptureTime']
        }],
        ResultToken=event['resultToken']
    )
    
    return {
        'compliance_type': compliance_type,
        'annotation': annotation
    }

# AWS Cost Explorer APIでコスト分析
# cost_analysis.py

import boto3
from datetime import datetime, timedelta

def get_cost_by_service(days=30):
    """サービス別コスト分析"""
    ce = boto3.client('ce')
    
    end_date = datetime.now().strftime('%Y-%m-%d')
    start_date = (
        datetime.now() - timedelta(days=days)
    ).strftime('%Y-%m-%d')
    
    response = ce.get_cost_and_usage(
        TimePeriod={
            'Start': start_date,
            'End': end_date
        },
        Granularity='MONTHLY',
        Metrics=['UnblendedCost'],
        GroupBy=[{
            'Type': 'DIMENSION',
            'Key': 'SERVICE'
        }]
    )
    
    costs = []
    for time_period in response['ResultsByTime']:
        for group in time_period['Groups']:
            service = group['Keys'][0]
            amount = float(
                group['Metrics']['UnblendedCost']['Amount']
            )
            if amount > 0:
                costs.append({
                    'service': service,
                    'cost': round(amount, 2)
                })
    
    costs.sort(key=lambda x: x['cost'], reverse=True)
    return costs


def detect_cost_anomalies(threshold_pct=20):
    """コスト異常検知: 前月比threshold%以上の増加でアラート"""
    ce = boto3.client('ce')
    
    current_month_start = datetime.now().replace(day=1).strftime('%Y-%m-%d')
    current_date = datetime.now().strftime('%Y-%m-%d')
    
    # 当月コスト取得
    current = ce.get_cost_and_usage(
        TimePeriod={
            'Start': current_month_start,
            'End': current_date
        },
        Granularity='MONTHLY',
        Metrics=['UnblendedCost'],
        GroupBy=[{'Type': 'DIMENSION', 'Key': 'SERVICE'}]
    )
    
    anomalies = []
    # 比較ロジック（日平均ベース）
    # ... 異常検知結果を返却
    
    return anomalies

-- GCP Billing ExportをBigQueryで分析
-- サービス別月次コストトレンド
SELECT
  invoice.month AS billing_month,
  service.description AS service_name,
  SUM(cost) + SUM(IFNULL(
    (SELECT SUM(c.amount) FROM UNNEST(credits) c), 0
  )) AS net_cost
FROM
  `project.dataset.gcp_billing_export_v1_XXXXXX`
WHERE
  invoice.month >= '202501'
GROUP BY
  billing_month, service_name
HAVING
  net_cost > 10
ORDER BY
  billing_month DESC, net_cost DESC;

-- プロジェクト別日次コスト追跡
SELECT
  FORMAT_DATE('%Y-%m-%d', usage_start_time) AS usage_date,
  project.name AS project_name,
  SUM(cost) AS daily_cost
FROM
  `project.dataset.gcp_billing_export_v1_XXXXXX`
WHERE
  usage_start_time >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY)
GROUP BY
  usage_date, project_name
ORDER BY
  usage_date DESC, daily_cost DESC;

一般的なEC2インスタンス使用率:

CPU使用率               メモリ使用率
┌──────────────┐        ┌──────────────┐
│████░░░░░░░░░░│        │██████░░░░░░░░│
│ 20-30%       │        │ 40-50%       │
└──────────────┘        └──────────────┘

=> 70-80%のCPUが無駄に！
=> 50-60%のメモリが無駄に！

# AWS Compute Optimizerでライトサイジング推奨を取得
# rightsizing_analyzer.py

import boto3

def get_ec2_recommendations():
    """EC2インスタンスのライトサイジング推奨を取得"""
    co = boto3.client('compute-optimizer')
    
    response = co.get_ec2_instance_recommendations(
        filters=[{
            'name': 'Finding',
            'values': ['OVER_PROVISIONED']
        }]
    )
    
    recommendations = []
    for rec in response['instanceRecommendations']:
        current = rec['currentInstanceType']
        finding = rec['finding']
        
        options = []
        for option in rec['recommendationOptions']:
            options.append({
                'instance_type': option['instanceType'],
                'migration_effort': option.get('migrationEffort', 'Unknown'),
                'performance_risk': option.get('performanceRisk', 0)
            })
        
        recommendations.append({
            'instance_id': rec['instanceArn'].split('/')[-1],
            'current_type': current,
            'finding': finding,
            'options': options,
            'utilization': rec.get('utilizationMetrics', [])
        })
    
    return recommendations

┌──────────────────────────────────────────────────────────────────┐
│              Reserved Instances vs Savings Plans                   │
├──────────────────┬──────────────────┬────────────────────────────┤
│ 項目              │ Reserved Instances│ Savings Plans              │
├──────────────────┼──────────────────┼────────────────────────────┤
│ 割引率            │ 最大72%         │ 最大72%                    │
│ 期間              │ 1年または3年    │ 1年または3年               │
│ インスタンス柔軟性│ 制限的(Standard)│ Compute SP: 非常に柔軟     │
│                   │ 中程度(Convert) │ EC2 SP: ファミリー内柔軟   │
│ リージョン柔軟性  │ Zonal/Regional  │ Compute SP: 全リージョン   │
│ サービス範囲      │ EC2のみ         │ EC2 + Fargate + Lambda     │
│ 支払いオプション  │ 全額/一部/なし  │ 全額/一部/なし             │
│ 推奨シナリオ      │ 安定的ワークロード│ 変動性あるワークロード    │
└──────────────────┴──────────────────┴────────────────────────────┘

# リザーブドインスタンスの損益分岐点分析
# break_even_analysis.py

def calculate_break_even(
    on_demand_hourly,
    ri_hourly,
    ri_upfront,
    term_months=12
):
    """RI損益分岐点の計算"""
    hours_per_month = 730  # 24 * 365 / 12
    
    # 月次節約額
    monthly_savings = (on_demand_hourly - ri_hourly) * hours_per_month
    
    if monthly_savings == 0:
        return None
    
    # 損益分岐点（月）
    break_even_months = ri_upfront / monthly_savings if ri_upfront > 0 else 0
    
    # 期間中の総節約額
    total_on_demand = on_demand_hourly * hours_per_month * term_months
    total_ri = ri_hourly * hours_per_month * term_months + ri_upfront
    total_savings = total_on_demand - total_ri
    savings_pct = (total_savings / total_on_demand) * 100
    
    return {
        'break_even_months': round(break_even_months, 1),
        'monthly_savings': round(monthly_savings, 2),
        'total_savings': round(total_savings, 2),
        'savings_percentage': round(savings_pct, 1)
    }


# 例: m5.xlarge (us-east-1)
result = calculate_break_even(
    on_demand_hourly=0.192,
    ri_hourly=0.0684,    # 3年一部前払い
    ri_upfront=1248.0,
    term_months=36
)
# 結果:
# break_even_months: 13.8
# total_savings: 約58%
# => 14ヶ月後から純利益発生

# Spotインスタンスの適合性判断基準
spot_suitable:
  - バッチ処理ジョブ
  - CI/CDパイプライン
  - データ分析 / ETL
  - ステートレスWebサーバー
  - コンテナ化されたマイクロサービス
  - 機械学習トレーニング
  - テスト環境

spot_not_suitable:
  - 単一インスタンスデータベース
  - 長時間実行のステートフルジョブ
  - 中断不可のプロダクションワークロード

# Spotインスタンス中断検知と処理
# spot_interruption_handler.py

import requests
import sys
import time
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

METADATA_URL = "http://169.254.169.254/latest/meta-data"
SPOT_ACTION_URL = f"{METADATA_URL}/spot/instance-action"


def check_spot_interruption():
    """Spot中断通知の確認（2分間の警告）"""
    try:
        response = requests.get(SPOT_ACTION_URL, timeout=2)
        if response.status_code == 200:
            data = response.json()
            return {
                'action': data.get('action'),
                'time': data.get('time'),
                'interrupted': True
            }
    except requests.exceptions.RequestException:
        pass
    return {'interrupted': False}


def graceful_shutdown(checkpoint_func=None):
    """グレースフルシャットダウン実行"""
    logger.info("Spot中断検知！グレースフルシャットダウン開始...")
    
    # 1. 新規タスク受付停止
    logger.info("新規タスクの受付を停止...")
    
    # 2. 現在の作業のチェックポイント保存
    if checkpoint_func:
        logger.info("チェックポイント保存中...")
        checkpoint_func()
    
    # 3. ロードバランサーからの登録解除
    logger.info("ロードバランサーから登録解除...")
    
    # 4. インフライトリクエストの完了待ち（最大90秒）
    logger.info("インフライトリクエスト完了待ち...")
    time.sleep(10)
    
    logger.info("グレースフルシャットダウン完了")


def spot_monitor_loop(checkpoint_func=None, interval=5):
    """Spot中断モニタリングループ"""
    logger.info("Spot中断モニター開始...")
    
    while True:
        status = check_spot_interruption()
        if status['interrupted']:
            graceful_shutdown(checkpoint_func)
            sys.exit(0)
        time.sleep(interval)

# Auto Scaling戦略比較
target_tracking:
  説明: "目標メトリクス値を維持"
  例: "CPU平均60%を維持"
  長所: "設定が簡単、自動調整"
  短所: "単一メトリクスに依存"

step_scaling:
  説明: "メトリクス範囲ごとのスケーリングステップ定義"
  例: "CPU 60-70%: +1, 70-80%: +2, 80%+: +4"
  長所: "きめ細かい制御"
  短所: "設定が複雑"

predictive_scaling:
  説明: "MLベースのトラフィック予測による事前スケーリング"
  例: "過去14日間のパターンを学習し事前にスケールアウト"
  長所: "事前対応、コールドスタート防止"
  短所: "不規則なトラフィックには不適"

schedule_based:
  説明: "時間ベースのスケジューリング"
  例: "平日9-18時: 10台、夜間: 2台"
  長所: "予測可能なコスト"
  短所: "突発的トラフィックに対応不足"

# Karpenter NodePool設定
apiVersion: karpenter.sh/v1beta1
kind: NodePool
metadata:
  name: default
spec:
  template:
    spec:
      requirements:
        - key: "karpenter.sh/capacity-type"
          operator: In
          values: ["spot", "on-demand"]
        - key: "kubernetes.io/arch"
          operator: In
          values: ["amd64"]
        - key: "karpenter.k8s.aws/instance-category"
          operator: In
          values: ["c", "m", "r"]
        - key: "karpenter.k8s.aws/instance-generation"
          operator: Gt
          values: ["4"]
      nodeClassRef:
        name: default
  limits:
    cpu: "1000"
    memory: "1000Gi"
  disruption:
    consolidationPolicy: WhenUnderutilized
    expireAfter: 720h
  weight: 50

{
  "Rules": [
    {
      "ID": "MoveToIntelligentTiering",
      "Status": "Enabled",
      "Filter": {
        "Prefix": "data/"
      },
      "Transitions": [
        {
          "Days": 0,
          "StorageClass": "INTELLIGENT_TIERING"
        }
      ]
    },
    {
      "ID": "ArchiveOldLogs",
      "Status": "Enabled",
      "Filter": {
        "Prefix": "logs/"
      },
      "Transitions": [
        {
          "Days": 30,
          "StorageClass": "STANDARD_IA"
        },
        {
          "Days": 90,
          "StorageClass": "GLACIER"
        },
        {
          "Days": 365,
          "StorageClass": "DEEP_ARCHIVE"
        }
      ],
      "Expiration": {
        "Days": 730
      }
    },
    {
      "ID": "CleanupIncompleteUploads",
      "Status": "Enabled",
      "Filter": {},
      "AbortIncompleteMultipartUpload": {
        "DaysAfterInitiation": 7
      }
    }
  ]
}

# EBS gp2 -> gp3マイグレーションスクリプト
# ebs_migration.py

import boto3

def find_gp2_volumes():
    """gp2ボリュームの検出と節約効果の計算"""
    ec2 = boto3.client('ec2')
    
    response = ec2.describe_volumes(
        Filters=[{
            'Name': 'volume-type',
            'Values': ['gp2']
        }]
    )
    
    volumes = []
    total_monthly_savings = 0
    
    for vol in response['Volumes']:
        size_gb = vol['Size']
        
        # gp2価格: $0.10/GB-month
        gp2_cost = size_gb * 0.10
        
        # gp3価格: $0.08/GB-month + IOPS/throughput追加分
        gp3_cost = size_gb * 0.08
        
        # gp2のベースラインIOPS = サイズ * 3（最小100）
        gp2_baseline_iops = max(size_gb * 3, 100)
        
        if gp2_baseline_iops > 3000:
            extra_iops = gp2_baseline_iops - 3000
            gp3_cost += extra_iops * 0.005
        
        savings = gp2_cost - gp3_cost
        total_monthly_savings += max(savings, 0)
        
        volumes.append({
            'volume_id': vol['VolumeId'],
            'size_gb': size_gb,
            'gp2_monthly_cost': round(gp2_cost, 2),
            'gp3_monthly_cost': round(gp3_cost, 2),
            'monthly_savings': round(max(savings, 0), 2)
        })
    
    return {
        'volumes': volumes,
        'total_monthly_savings': round(total_monthly_savings, 2)
    }

# HelmでKubecostをインストール
helm repo add kubecost https://kubecost.github.io/cost-analyzer/
helm repo update

helm install kubecost kubecost/cost-analyzer \
  --namespace kubecost \
  --create-namespace \
  --set kubecostToken="YOUR_TOKEN" \
  --set prometheus.server.retention="15d" \
  --set persistentVolume.enabled=true \
  --set persistentVolume.size="32Gi"

# Kubecostコスト配分設定
apiVersion: v1
kind: ConfigMap
metadata:
  name: allocation-config
  namespace: kubecost
data:
  allocation.json: |
    {
      "sharedNamespaces": [
        "kube-system",
        "kubecost",
        "monitoring",
        "istio-system"
      ],
      "labelConfig": {
        "enabled": true,
        "team_label": "team",
        "department_label": "department",
        "product_label": "product"
      }
    }

# Namespace別リソースクォータ
apiVersion: v1
kind: ResourceQuota
metadata:
  name: team-backend-quota
  namespace: backend
spec:
  hard:
    requests.cpu: "20"
    requests.memory: "40Gi"
    limits.cpu: "40"
    limits.memory: "80Gi"
    pods: "50"
    services.loadbalancers: "2"
---
# デフォルトリソース制限
apiVersion: v1
kind: LimitRange
metadata:
  name: default-limits
  namespace: backend
spec:
  limits:
    - default:
        cpu: "500m"
        memory: "512Mi"
      defaultRequest:
        cpu: "100m"
        memory: "128Mi"
      max:
        cpu: "4"
        memory: "8Gi"
      min:
        cpu: "50m"
        memory: "64Mi"
      type: Container

# VPAによるPodリソースの自動最適化
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: user-api-vpa
  namespace: backend
spec:
  targetRef:
    apiVersion: "apps/v1"
    kind: Deployment
    name: user-api
  updatePolicy:
    updateMode: "Auto"
  resourcePolicy:
    containerPolicies:
      - containerName: user-api
        minAllowed:
          cpu: "50m"
          memory: "64Mi"
        maxAllowed:
          cpu: "2"
          memory: "4Gi"
        controlledResources: ["cpu", "memory"]
        controlledValues: RequestsAndLimits

# GPU Spotインスタンスを活用したMLトレーニングコスト最適化
# ml_cost_optimizer.py

import boto3

def estimate_training_cost(
    instance_type,
    num_instances,
    training_hours,
    use_spot=True,
    spot_discount=0.7
):
    """MLトレーニングコストの見積もり"""
    on_demand_prices = {
        'p3.2xlarge': 3.06,
        'p3.8xlarge': 12.24,
        'p4d.24xlarge': 32.77,
        'g4dn.xlarge': 0.526,
        'g5.xlarge': 1.006,
    }
    
    hourly_rate = on_demand_prices.get(instance_type, 0)
    if use_spot:
        hourly_rate *= (1 - spot_discount)
    
    total_cost = hourly_rate * num_instances * training_hours
    
    return {
        'instance_type': instance_type,
        'num_instances': num_instances,
        'training_hours': training_hours,
        'use_spot': use_spot,
        'hourly_rate_per_instance': round(hourly_rate, 3),
        'total_estimated_cost': round(total_cost, 2)
    }

# SageMaker Managed Spot Trainingの設定
# sagemaker_optimizer.py

import boto3

def setup_managed_spot_training(
    training_job_name,
    role_arn,
    image_uri,
    instance_type='ml.p3.2xlarge'
):
    """SageMaker Managed Spot Trainingの設定"""
    sm = boto3.client('sagemaker')
    
    response = sm.create_training_job(
        TrainingJobName=training_job_name,
        RoleArn=role_arn,
        AlgorithmSpecification={
            'TrainingImage': image_uri,
            'TrainingInputMode': 'File'
        },
        ResourceConfig={
            'InstanceType': instance_type,
            'InstanceCount': 1,
            'VolumeSizeInGB': 50
        },
        # Spot Training核心設定
        EnableManagedSpotTraining=True,
        StoppingCondition={
            'MaxRuntimeInSeconds': 3600,
            'MaxWaitTimeInSeconds': 7200
        },
        # チェックポイント設定（Spot中断時の復旧用）
        CheckpointConfig={
            'S3Uri': f's3://my-bucket/checkpoints/{training_job_name}'
        },
        InputDataConfig=[{
            'ChannelName': 'training',
            'DataSource': {
                'S3DataSource': {
                    'S3DataType': 'S3Prefix',
                    'S3Uri': 's3://my-bucket/training-data/'
                }
            }
        }],
        OutputDataConfig={
            'S3OutputPath': 's3://my-bucket/output/'
        }
    )
    
    return response

AWSデータ転送コスト構造:

インターネット -> AWS:          無料
AWS -> インターネット:          $0.09/GB（最初の10TB）
同一AZ内（プライベートIP）:    無料
同一リージョン、異なるAZ:      $0.01/GB（各方向）
異なるリージョン:              $0.02/GB
AWS -> CloudFront:              無料
NAT Gateway処理:               $0.045/GB + $0.045/時間

主要コストトラップ:
1. NAT Gateway経由のS3/DynamoDBトラフィック -> VPC Endpointで削減
2. クロスAZトラフィック -> サービスメッシュまたはAZ対応ルーティング
3. 不要なリージョン間レプリケーション -> 選択的レプリケーション

# VPC Endpoint設定（Terraform）

# S3 Gateway Endpoint（無料）
resource "aws_vpc_endpoint" "s3" {
  vpc_id       = aws_vpc.main.id
  service_name = "com.amazonaws.ap-northeast-1.s3"
  
  route_table_ids = [
    aws_route_table.private_a.id,
    aws_route_table.private_b.id,
  ]
  
  tags = {
    Name = "s3-vpc-endpoint"
  }
}

# DynamoDB Gateway Endpoint（無料）
resource "aws_vpc_endpoint" "dynamodb" {
  vpc_id       = aws_vpc.main.id
  service_name = "com.amazonaws.ap-northeast-1.dynamodb"
  
  route_table_ids = [
    aws_route_table.private_a.id,
    aws_route_table.private_b.id,
  ]
  
  tags = {
    Name = "dynamodb-vpc-endpoint"
  }
}

# ECR Interface Endpoint
resource "aws_vpc_endpoint" "ecr_api" {
  vpc_id              = aws_vpc.main.id
  service_name        = "com.amazonaws.ap-northeast-1.ecr.api"
  vpc_endpoint_type   = "Interface"
  private_dns_enabled = true
  
  subnet_ids = [
    aws_subnet.private_a.id,
    aws_subnet.private_b.id,
  ]
  
  security_group_ids = [
    aws_security_group.vpc_endpoints.id
  ]
}

# FinOpsオープンソースツール比較
infracost:
  説明: "Terraform PRにコスト影響の推定コメント"
  統合: "GitHub Actions, GitLab CI, Atlantis"
  長所: "コード変更前にコストを認識"

opencost:
  説明: "K8sコストモニタリング（CNCFプロジェクト）"
  統合: "Prometheus, Grafana, K8s"
  長所: "リアルタイムK8sコストモニタリング、完全オープンソース"

komiser:
  説明: "マルチクラウドコストダッシュボード"
  統合: "AWS, GCP, Azure, DigitalOcean"
  長所: "セルフホスティング、マルチクラウド対応"

vantage:
  説明: "クラウドコスト透明性プラットフォーム"
  統合: "AWS, GCP, Azure, Datadog, Snowflake"
  長所: "ユニットコスト追跡、コストレポート"

# GitHub ActionsでInfracostを使用
name: Infracost
on:
  pull_request:
    paths:
      - '**.tf'
      - '**.tfvars'

jobs:
  infracost:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Infracost
        uses: infracost/actions/setup@v3
        with:
          api-key: "${{ secrets.INFRACOST_API_KEY }}"

      - name: Generate Infracost diff
        run: |
          infracost diff \
            --path=. \
            --format=json \
            --out-file=/tmp/infracost.json

      - name: Post Infracost comment
        uses: infracost/actions/comment@v1
        with:
          path: /tmp/infracost.json
          behavior: update

Showback（ショーバック）:
├── 各チームにコストを「見せる」
├── 実際の予算から差し引かない
├── 意識向上が目的
├── FinOps開始段階に適切
└── リスク: 行動変化のモチベーション不足

Chargeback（チャージバック）:
├── 各チームの予算から実際に差し引く
├── 強いコスト意識のモチベーション
├── 正確なコスト配分が必要
├── FinOps成熟段階に適切
└── リスク: 共有リソース配分の紛争

# ユニットエコノミクスダッシュボードデータの生成
# unit_economics.py

def calculate_unit_economics(
    total_cloud_cost,
    total_revenue,
    active_users,
    total_transactions,
    total_api_calls
):
    """ビジネスユニットあたりのクラウドコスト計算"""
    
    cloud_cost_ratio = (total_cloud_cost / total_revenue) * 100
    
    return {
        'cost_per_user': round(
            total_cloud_cost / active_users, 4
        ),
        'cost_per_transaction': round(
            total_cloud_cost / total_transactions, 6
        ),
        'cost_per_1k_api_calls': round(
            (total_cloud_cost / total_api_calls) * 1000, 4
        ),
        'cloud_cost_revenue_ratio': round(cloud_cost_ratio, 2),
        'gross_margin_impact': round(100 - cloud_cost_ratio, 2)
    }


# 例
metrics = calculate_unit_economics(
    total_cloud_cost=50000,
    total_revenue=500000,
    active_users=100000,
    total_transactions=2000000,
    total_api_calls=500000000
)
# 結果:
# cost_per_user: $0.50
# cost_per_transaction: $0.025
# cloud_cost_revenue_ratio: 10.0%

# FinOpsコスト最適化チェックリスト
immediate_wins:  # 即時実行可能
  - "未使用EBSボリュームの削除"
  - "未関連付けElastic IPの解放"
  - "gp2からgp3への移行"
  - "前世代インスタンスのアップグレード（m4 -> m6i）"
  - "開発環境の夜間/週末停止"
  - "古いスナップショットの整理"
  - "S3 Intelligent-Tieringの有効化"

short_term:  # 1〜3ヶ月
  - "Reserved Instances / Savings Plansの購入"
  - "Spotインスタンスの導入（適切なワークロード）"
  - "Auto Scalingの最適化"
  - "VPC Endpointの設定"
  - "タギング戦略の策定と適用"
  - "コストアラートの設定"

long_term:  # 3〜12ヶ月
  - "Karpenterの導入（K8s）"
  - "Kubecostベースのコスト配分"
  - "ユニットエコノミクス追跡体系"
  - "FinOps文化の定着"
  - "マルチクラウドコスト最適化"
  - "Infracost CI/CD統合"