8장: 비용 가시성과 FinOps 통합

import React from 'react';
import { Typography, Card, CardContent } from '@material-ui/core';
 
interface CostEstimateProps {
  database: string;
  size: string;
  environment: string;
}
 
function CostEstimate({
  database,
  size,
  environment,
}: CostEstimateProps) {
  const estimates: Record<string, Record<string, number>> = {
    postgresql: { small: 25, medium: 95, large: 380 },
    mysql: { small: 22, medium: 88, large: 350 },
  };
 
  const monthlyCost = estimates[database]?.[size] ?? 0;
  const environmentMultiplier =
    environment === 'production' ? 2.5 : 1.0; // production은 Multi-AZ
  const totalMonthlyCost = monthlyCost * environmentMultiplier;
 
  return (
    <Card variant="outlined">
      <CardContent>
        <Typography variant="h6">예상 월 비용</Typography>
        <Typography variant="h4">
          ${totalMonthlyCost.toFixed(0)} USD / 월
        </Typography>
        <Typography variant="body2" color="textSecondary">
          {database} ({size}) - {environment}
          {environment === 'production' && ' (Multi-AZ 포함)'}
        </Typography>
      </CardContent>
    </Card>
  );
}
 
export { CostEstimate };

name: Infracost
 
on:
  pull_request:
    paths:
      - "terraform/**"
      - "crossplane/**"
 
jobs:
  infracost:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Setup Infracost
        uses: infracost/actions/setup@v3
        with:
          api-key: ${{ secrets.INFRACOST_API_KEY }}
 
      - name: Generate cost diff
        run: |
          infracost diff \
            --path=terraform/ \
            --format=json \
            --out-file=/tmp/infracost.json
 
      - name: Post PR comment
        uses: infracost/actions/comment@v3
        with:
          path: /tmp/infracost.json
          behavior: update

import { CostInsightsPage } from '@backstage/plugin-cost-insights';
 
// App 라우트에 추가
<Route path="/cost-insights" element={<CostInsightsPage />} />

import {
  CostInsightsApi,
  Alert,
  Cost,
  Group,
  MetricData,
  Project,
} from '@backstage/plugin-cost-insights-common';
 
export class MyCostInsightsClient implements CostInsightsApi {
  async getLastCompleteBillingDate(): Promise<string> {
    // 가장 최근 완료된 청구 날짜 반환
    const today = new Date();
    today.setDate(today.getDate() - 1);
    return today.toISOString().split('T')[0];
  }
 
  async getUserGroups(userId: string): Promise<Group[]> {
    // 사용자가 속한 팀/그룹 반환
    const response = await fetch(
      `${this.baseUrl}/api/groups?userId=${userId}`,
    );
    return response.json();
  }
 
  async getGroupDailyCost(
    group: string,
    intervals: string,
  ): Promise<Cost> {
    // 팀별 일일 비용 데이터 반환
    const response = await fetch(
      `${this.baseUrl}/api/costs/daily?group=${group}&intervals=${intervals}`,
    );
    return response.json();
  }
 
  async getProjectDailyCost(
    project: string,
    intervals: string,
  ): Promise<Cost> {
    // 서비스(프로젝트)별 일일 비용 데이터 반환
    const response = await fetch(
      `${this.baseUrl}/api/costs/daily?project=${project}&intervals=${intervals}`,
    );
    return response.json();
  }
 
  async getDailyMetricData(
    metric: string,
    intervals: string,
  ): Promise<MetricData> {
    const response = await fetch(
      `${this.baseUrl}/api/metrics/daily?metric=${metric}&intervals=${intervals}`,
    );
    return response.json();
  }
 
  async getAlerts(group: string): Promise<Alert[]> {
    // 비용 관련 알림 반환
    const response = await fetch(
      `${this.baseUrl}/api/alerts?group=${group}`,
    );
    return response.json();
  }
}

required_tags:
  - key: "team"
    description: "리소스를 소유하는 팀"
    example: "checkout-team"
    source: "catalog-info.yaml의 spec.owner"
 
  - key: "service"
    description: "리소스가 속한 서비스"
    example: "checkout-service"
    source: "catalog-info.yaml의 metadata.name"
 
  - key: "environment"
    description: "배포 환경"
    example: "production"
    allowed_values: ["dev", "staging", "production"]
 
  - key: "cost-center"
    description: "비용 센터 코드"
    example: "CC-001"
    source: "팀 메타데이터에서 자동 매핑"
 
  - key: "managed-by"
    description: "리소스 관리 도구"
    example: "crossplane"
    allowed_values: ["terraform", "crossplane", "manual"]
 
optional_tags:
  - key: "project"
    description: "프로젝트 또는 이니셔티브"
    example: "checkout-v2-migration"
 
  - key: "ttl"
    description: "리소스 만료 시간 (dev 환경용)"
    example: "72h"

locals {
  common_tags = {
    team        = var.team
    service     = var.service_name
    environment = var.environment
    cost-center = var.cost_center
    managed-by  = "terraform"
    created-at  = timestamp()
    created-by  = var.created_by
  }
}
 
# 모든 리소스에 공통 태그 적용
resource "aws_db_instance" "main" {
  # ... 설정 ...
  tags = merge(local.common_tags, {
    resource-type = "database"
  })
}
 
resource "aws_elasticache_cluster" "main" {
  # ... 설정 ...
  tags = merge(local.common_tags, {
    resource-type = "cache"
  })
}

import boto3
from typing import Any
 
 
REQUIRED_TAGS = ['team', 'service', 'environment', 'cost-center', 'managed-by']
 
 
def check_tag_compliance(resource: dict[str, Any]) -> list[str]:
    """리소스의 태그 컴플라이언스를 검사합니다."""
    existing_tags = {
        tag['Key']: tag['Value']
        for tag in resource.get('Tags', [])
    }
 
    missing_tags = [
        tag for tag in REQUIRED_TAGS
        if tag not in existing_tags
    ]
 
    return missing_tags
 
 
def scan_rds_instances() -> list[dict[str, Any]]:
    """RDS 인스턴스의 태그 컴플라이언스를 스캔합니다."""
    rds = boto3.client('rds', region_name='ap-northeast-2')
    instances = rds.describe_db_instances()
 
    non_compliant = []
    for instance in instances['DBInstances']:
        arn = instance['DBInstanceArn']
        tags_response = rds.list_tags_for_resource(ResourceName=arn)
        instance['Tags'] = tags_response['TagList']
 
        missing = check_tag_compliance(instance)
        if missing:
            non_compliant.append({
                'resource_id': instance['DBInstanceIdentifier'],
                'resource_type': 'RDS',
                'missing_tags': missing,
            })
 
    return non_compliant

budgets:
  - name: "checkout-team-monthly"
    team: checkout-team
    period: monthly
    amount: 5000   # USD
    alerts:
      - threshold: 50    # 50% 도달 시
        channels: ["slack:checkout-team-alerts"]
        severity: info
      - threshold: 80    # 80% 도달 시
        channels: ["slack:checkout-team-alerts", "email:team-lead"]
        severity: warning
      - threshold: 100   # 100% 도달 시
        channels: ["slack:checkout-team-alerts", "email:team-lead", "email:cto"]
        severity: critical
 
  - name: "dev-environment-total"
    scope: environment:dev
    period: monthly
    amount: 10000  # USD
    alerts:
      - threshold: 90
        channels: ["slack:platform-team"]
        severity: warning

interface CostEstimateInput {
  template: string;
  database?: string;
  messaging?: string;
  environment?: string;
}
 
interface CostEstimateResult {
  monthly: number;
  breakdown: CostBreakdownItem[];
  comparison: string;
}
 
interface CostBreakdownItem {
  resource: string;
  monthlyCost: number;
}
 
const COST_TABLE: Record<string, Record<string, number>> = {
  compute: {
    'spring-boot': 45,     // EKS Pod (0.5 vCPU, 1Gi) x 2 replicas
    'go-grpc': 30,         // EKS Pod (0.25 vCPU, 512Mi) x 2 replicas
    'fastapi': 35,         // EKS Pod (0.25 vCPU, 512Mi) x 2 replicas
    'nextjs': 20,          // EKS Pod (0.25 vCPU, 256Mi) x 2 replicas
  },
  database: {
    postgresql_small: 25,
    postgresql_medium: 95,
    postgresql_large: 380,
    mysql_small: 22,
    mysql_medium: 88,
    mysql_large: 350,
  },
  messaging: {
    kafka: 150,
    rabbitmq: 45,
  },
};
 
export class CostEstimator {
  static async estimate(input: CostEstimateInput): Promise<CostEstimateResult> {
    const breakdown: CostBreakdownItem[] = [];
 
    // 컴퓨트 비용
    const computeCost = COST_TABLE.compute[input.template] ?? 40;
    breakdown.push({ resource: 'Compute (EKS)', monthlyCost: computeCost });
 
    // 데이터베이스 비용
    if (input.database && input.database !== 'none') {
      const dbKey = `${input.database}_small`;
      const dbCost = COST_TABLE.database[dbKey] ?? 0;
      breakdown.push({ resource: `Database (${input.database})`, monthlyCost: dbCost });
    }
 
    // 메시징 비용
    if (input.messaging && input.messaging !== 'none') {
      const msgCost = COST_TABLE.messaging[input.messaging] ?? 0;
      breakdown.push({ resource: `Messaging (${input.messaging})`, monthlyCost: msgCost });
    }
 
    // CI/CD, 모니터링 등 공통 비용
    breakdown.push({ resource: 'CI/CD + Monitoring', monthlyCost: 15 });
 
    const monthly = breakdown.reduce((sum, item) => sum + item.monthlyCost, 0);
 
    return {
      monthly,
      breakdown,
      comparison: `팀 월 예산의 ${((monthly / 5000) * 100).toFixed(1)}%에 해당합니다.`,
    };
  }
}

# Kubecost Helm 설치 설정
kubecostProductConfigs:
  clusterName: "production-cluster"
  defaultModelPricing:
    enabled: true
    CPU: "0.031611"    # ap-northeast-2 m6i.large 기준
    RAM: "0.004237"
    GPU: "0.95"
    storage: "0.000127"
 
  labelMappingConfigs:
    enabled: true
    team_label: "team"
    service_label: "service"
    environment_label: "environment"
 
# Backstage 연동을 위한 API 노출
service:
  type: ClusterIP
  port: 9090

optimization_rules:
  - name: "유휴 리소스 감지"
    description: "72시간 이상 CPU 사용률 5% 미만인 워크로드 탐지"
    action: "스케일 다운 또는 제거 추천"
    automation: semi-auto  # 추천 후 수동 승인
 
  - name: "오버프로비저닝 감지"
    description: "실제 사용량 대비 2배 이상 할당된 리소스 탐지"
    action: "리소스 리밋 조정 추천"
    automation: semi-auto
 
  - name: "스팟 인스턴스 전환"
    description: "Stateless 워크로드를 스팟 인스턴스로 전환"
    action: "dev/staging 환경 자동 전환"
    automation: auto  # dev/staging만 자동
 
  - name: "비용 이상 탐지"
    description: "전주 대비 30% 이상 비용 증가 서비스 탐지"
    action: "팀 리드에게 알림"
    automation: auto