# Экономика облака и калькулятор затрат

## Навигация
- [🏠 Главная страница курса](../../../README.md)
- [📚 Модуль 8](../README.md)

---

## Основы экономики облака

### 1. Модели ценообразования

#### Pay-as-you-go (PAYG)
- Оплата только за используемые ресурсы
- Гибкость в масштабировании
- Низкие начальные затраты

```javascript
// Калькулятор затрат для Pay-as-you-go
class PayAsYouGoCalculator {
    constructor() {
        this.resources = {
            compute: {
                instances: [],
                storage: [],
                networking: []
            },
            database: {
                instances: [],
                storage: []
            },
            services: {
                monitoring: [],
                security: [],
                backup: []
            }
        };
    }

    addComputeInstance(instance) {
        this.resources.compute.instances.push({
            type: instance.type,
            region: instance.region,
            hours: instance.hours,
            pricePerHour: instance.pricePerHour,
            monthlyCost: instance.hours * instance.pricePerHour * 30
        });
    }

    addStorage(storage) {
        this.resources.compute.storage.push({
            type: storage.type,
            size: storage.size, // GB
            pricePerGB: storage.pricePerGB,
            monthlyCost: storage.size * storage.pricePerGB
        });
    }

    calculateMonthlyCost() {
        let totalCost = 0;
        
        // Compute costs
        totalCost += this.resources.compute.instances.reduce((sum, instance) => sum + instance.monthlyCost, 0);
        totalCost += this.resources.compute.storage.reduce((sum, storage) => sum + storage.monthlyCost, 0);
        
        // Database costs
        totalCost += this.resources.database.instances.reduce((sum, instance) => sum + instance.monthlyCost, 0);
        totalCost += this.resources.database.storage.reduce((sum, storage) => sum + storage.monthlyCost, 0);
        
        // Services costs
        totalCost += this.resources.services.monitoring.reduce((sum, service) => sum + service.monthlyCost, 0);
        totalCost += this.resources.services.security.reduce((sum, service) => sum + service.monthlyCost, 0);
        totalCost += this.resources.services.backup.reduce((sum, service) => sum + service.monthlyCost, 0);
        
        return totalCost;
    }

    generateReport() {
        const monthlyCost = this.calculateMonthlyCost();
        const yearlyCost = monthlyCost * 12;
        
        return {
            monthlyCost: monthlyCost,
            yearlyCost: yearlyCost,
            breakdown: {
                compute: this.resources.compute.instances.reduce((sum, instance) => sum + instance.monthlyCost, 0) +
                        this.resources.compute.storage.reduce((sum, storage) => sum + storage.monthlyCost, 0),
                database: this.resources.database.instances.reduce((sum, instance) => sum + instance.monthlyCost, 0) +
                         this.resources.database.storage.reduce((sum, storage) => sum + storage.monthlyCost, 0),
                services: this.resources.services.monitoring.reduce((sum, service) => sum + service.monthlyCost, 0) +
                         this.resources.services.security.reduce((sum, service) => sum + service.monthlyCost, 0) +
                         this.resources.services.backup.reduce((sum, service) => sum + service.monthlyCost, 0)
            }
        };
    }
}

// Использование калькулятора
const calculator = new PayAsYouGoCalculator();

// Добавление compute instances
calculator.addComputeInstance({
    type: 't3.medium',
    region: 'us-east-1',
    hours: 24,
    pricePerHour: 0.0416
});

calculator.addComputeInstance({
    type: 't3.large',
    region: 'us-east-1',
    hours: 24,
    pricePerHour: 0.0832
});

// Добавление storage
calculator.addStorage({
    type: 'gp3',
    size: 1000, // 1TB
    pricePerGB: 0.08
});

// Генерация отчета
const report = calculator.generateReport();
console.log('Monthly Cost:', report.monthlyCost);
console.log('Yearly Cost:', report.yearlyCost);
console.log('Breakdown:', report.breakdown);
```

#### Reserved Instances
- Предоплата за 1-3 года
- Скидка до 75%
- Предсказуемые затраты

```javascript
// Калькулятор для Reserved Instances
class ReservedInstanceCalculator {
    constructor() {
        this.instances = [];
    }

    addReservedInstance(instance) {
        this.instances.push({
            type: instance.type,
            region: instance.region,
            term: instance.term, // 1 or 3 years
            paymentOption: instance.paymentOption, // 'No Upfront', 'Partial Upfront', 'All Upfront'
            upfrontCost: instance.upfrontCost,
            monthlyCost: instance.monthlyCost,
            totalCost: instance.upfrontCost + (instance.monthlyCost * instance.term * 12)
        });
    }

    calculateSavings(ondemandCost) {
        const reservedCost = this.instances.reduce((sum, instance) => sum + instance.totalCost, 0);
        const savings = ondemandCost - reservedCost;
        const savingsPercentage = (savings / ondemandCost) * 100;
        
        return {
            ondemandCost: ondemandCost,
            reservedCost: reservedCost,
            savings: savings,
            savingsPercentage: savingsPercentage
        };
    }
}

// Пример использования
const reservedCalculator = new ReservedInstanceCalculator();

reservedCalculator.addReservedInstance({
    type: 't3.medium',
    region: 'us-east-1',
    term: 1,
    paymentOption: 'No Upfront',
    upfrontCost: 0,
    monthlyCost: 30
});

const ondemandCost = 50; // Monthly on-demand cost
const savings = reservedCalculator.calculateSavings(ondemandCost * 12);
console.log('Savings:', savings);
```

#### Spot Instances
- Использование неиспользуемых ресурсов
- Скидка до 90%
- Риск прерывания

```javascript
// Калькулятор для Spot Instances
class SpotInstanceCalculator {
    constructor() {
        this.instances = [];
    }

    addSpotInstance(instance) {
        this.instances.push({
            type: instance.type,
            region: instance.region,
            spotPrice: instance.spotPrice,
            ondemandPrice: instance.ondemandPrice,
            interruptionRate: instance.interruptionRate, // Percentage
            monthlyCost: instance.spotPrice * 24 * 30,
            ondemandCost: instance.ondemandPrice * 24 * 30
        });
    }

    calculateSavings() {
        const totalSpotCost = this.instances.reduce((sum, instance) => sum + instance.monthlyCost, 0);
        const totalOndemandCost = this.instances.reduce((sum, instance) => sum + instance.ondemandCost, 0);
        const savings = totalOndemandCost - totalSpotCost;
        const savingsPercentage = (savings / totalOndemandCost) * 100;
        
        return {
            spotCost: totalSpotCost,
            ondemandCost: totalOndemandCost,
            savings: savings,
            savingsPercentage: savingsPercentage
        };
    }

    calculateRisk() {
        const totalInterruptionRate = this.instances.reduce((sum, instance) => sum + instance.interruptionRate, 0) / this.instances.length;
        
        return {
            averageInterruptionRate: totalInterruptionRate,
            riskLevel: totalInterruptionRate > 20 ? 'High' : totalInterruptionRate > 10 ? 'Medium' : 'Low',
            recommendation: totalInterruptionRate > 20 ? 'Use for non-critical workloads only' : 'Suitable for most workloads'
        };
    }
}
```

### 2. Компоненты затрат

#### Compute Costs
- EC2 instances, Azure VMs, GCP Compute Engine
- CPU, Memory, Storage
- Operating System licensing

#### Storage Costs
- Block storage (EBS, Azure Disks, GCP Persistent Disk)
- Object storage (S3, Azure Blob, GCP Cloud Storage)
- Database storage

#### Networking Costs
- Data transfer
- Load balancers
- CDN

#### Services Costs
- Monitoring and logging
- Security services
- Backup and disaster recovery

### 3. Оптимизация затрат

#### Right-sizing
- Выбор правильного размера инстансов
- Мониторинг использования ресурсов
- Автоматическое масштабирование

```javascript
// Right-sizing рекомендации
class RightSizingAnalyzer {
    constructor() {
        this.metrics = [];
    }

    addMetrics(instanceId, metrics) {
        this.metrics.push({
            instanceId: instanceId,
            cpuUtilization: metrics.cpuUtilization,
            memoryUtilization: metrics.memoryUtilization,
            networkUtilization: metrics.networkUtilization,
            storageUtilization: metrics.storageUtilization,
            timestamp: new Date()
        });
    }

    analyzeUtilization() {
        const recommendations = [];
        
        this.metrics.forEach(metric => {
            const recommendation = {
                instanceId: metric.instanceId,
                currentUtilization: {
                    cpu: metric.cpuUtilization,
                    memory: metric.memoryUtilization,
                    network: metric.networkUtilization,
                    storage: metric.storageUtilization
                },
                recommendations: []
            };

            // CPU recommendations
            if (metric.cpuUtilization < 20) {
                recommendation.recommendations.push({
                    type: 'CPU',
                    action: 'Downsize',
                    reason: 'CPU utilization is below 20%',
                    potentialSavings: '30-50%'
                });
            } else if (metric.cpuUtilization > 80) {
                recommendation.recommendations.push({
                    type: 'CPU',
                    action: 'Upsize',
                    reason: 'CPU utilization is above 80%',
                    potentialCost: '20-30% increase'
                });
            }

            // Memory recommendations
            if (metric.memoryUtilization < 30) {
                recommendation.recommendations.push({
                    type: 'Memory',
                    action: 'Downsize',
                    reason: 'Memory utilization is below 30%',
                    potentialSavings: '25-40%'
                });
            } else if (metric.memoryUtilization > 90) {
                recommendation.recommendations.push({
                    type: 'Memory',
                    action: 'Upsize',
                    reason: 'Memory utilization is above 90%',
                    potentialCost: '15-25% increase'
                });
            }

            recommendations.push(recommendation);
        });

        return recommendations;
    }
}
```

#### Reserved Instances Planning
- Анализ использования ресурсов
- Планирование покупки RI
- Оптимизация портфеля RI

```javascript
// Reserved Instances планировщик
class ReservedInstancePlanner {
    constructor() {
        this.usageHistory = [];
    }

    addUsageHistory(instanceType, region, hours, months) {
        this.usageHistory.push({
            instanceType: instanceType,
            region: region,
            hours: hours,
            months: months,
            utilizationRate: hours / (months * 30 * 24)
        });
    }

    calculateRIRecommendations() {
        const recommendations = [];
        
        // Группировка по типу инстанса и региону
        const groupedUsage = this.usageHistory.reduce((acc, usage) => {
            const key = `${usage.instanceType}-${usage.region}`;
            if (!acc[key]) {
                acc[key] = {
                    instanceType: usage.instanceType,
                    region: usage.region,
                    totalHours: 0,
                    totalMonths: 0,
                    utilizationRate: 0
                };
            }
            acc[key].totalHours += usage.hours;
            acc[key].totalMonths += usage.months;
            acc[key].utilizationRate = acc[key].totalHours / (acc[key].totalMonths * 30 * 24);
            return acc;
        }, {});

        Object.values(groupedUsage).forEach(usage => {
            if (usage.utilizationRate > 0.7) { // 70% utilization
                recommendations.push({
                    instanceType: usage.instanceType,
                    region: usage.region,
                    utilizationRate: usage.utilizationRate,
                    recommendation: 'Strong candidate for Reserved Instance',
                    potentialSavings: '30-60%',
                    term: usage.utilizationRate > 0.9 ? '3 years' : '1 year'
                });
            }
        });

        return recommendations;
    }
}
```

#### Spot Instances Strategy
- Анализ толерантности к прерываниям
- Выбор подходящих workload
- Гибридная стратегия

```javascript
// Spot Instances стратегия
class SpotInstanceStrategy {
    constructor() {
        this.workloads = [];
    }

    addWorkload(workload) {
        this.workloads.push({
            name: workload.name,
            type: workload.type,
            criticality: workload.criticality, // 'low', 'medium', 'high'
            interruptionTolerance: workload.interruptionTolerance, // 'low', 'medium', 'high'
            duration: workload.duration, // hours
            spotEligibility: this.calculateSpotEligibility(workload)
        });
    }

    calculateSpotEligibility(workload) {
        let score = 0;
        
        // Criticality scoring
        if (workload.criticality === 'low') score += 3;
        else if (workload.criticality === 'medium') score += 2;
        else score += 1;

        // Interruption tolerance scoring
        if (workload.interruptionTolerance === 'high') score += 3;
        else if (workload.interruptionTolerance === 'medium') score += 2;
        else score += 1;

        // Duration scoring (shorter is better for spot)
        if (workload.duration < 1) score += 3;
        else if (workload.duration < 4) score += 2;
        else score += 1;

        return {
            score: score,
            recommendation: score >= 7 ? 'Highly recommended' : score >= 5 ? 'Recommended' : 'Not recommended',
            potentialSavings: score >= 7 ? '60-90%' : score >= 5 ? '40-60%' : '20-40%'
        };
    }

    generateStrategy() {
        const strategy = {
            spotWorkloads: [],
            ondemandWorkloads: [],
            hybridWorkloads: []
        };

        this.workloads.forEach(workload => {
            if (workload.spotEligibility.score >= 7) {
                strategy.spotWorkloads.push(workload);
            } else if (workload.spotEligibility.score >= 5) {
                strategy.hybridWorkloads.push(workload);
            } else {
                strategy.ondemandWorkloads.push(workload);
            }
        });

        return strategy;
    }
}
```

## Калькуляторы затрат

### 1. AWS Pricing Calculator
- Детальный расчет затрат
- Различные типы инстансов
- Региональные различия

### 2. Azure Pricing Calculator
- Комплексный калькулятор
- Различные сервисы
- Скидки и предложения

### 3. GCP Pricing Calculator
- Интерактивный калькулятор
- Детализация по сервисам
- Экспорт в различные форматы

### 4. Third-party Tools
- CloudHealth
- Cloudyn
- Cloudability

## TCO (Total Cost of Ownership)

### 1. On-premises vs Cloud
- Сравнение затрат
- Учет всех компонентов
- Долгосрочная перспектива

```javascript
// TCO калькулятор
class TCOCalculator {
    constructor() {
        this.onPremisesCosts = {
            hardware: 0,
            software: 0,
            maintenance: 0,
            power: 0,
            cooling: 0,
            space: 0,
            personnel: 0,
            security: 0,
            backup: 0,
            disasterRecovery: 0
        };
        
        this.cloudCosts = {
            compute: 0,
            storage: 0,
            networking: 0,
            services: 0,
            support: 0,
            migration: 0,
            training: 0
        };
    }

    setOnPremisesCosts(costs) {
        this.onPremisesCosts = { ...this.onPremisesCosts, ...costs };
    }

    setCloudCosts(costs) {
        this.cloudCosts = { ...this.cloudCosts, ...costs };
    }

    calculateTCO(years = 3) {
        const onPremisesTotal = Object.values(this.onPremisesCosts).reduce((sum, cost) => sum + cost, 0) * years;
        const cloudTotal = Object.values(this.cloudCosts).reduce((sum, cost) => sum + cost, 0) * years;
        
        return {
            onPremises: {
                total: onPremisesTotal,
                yearly: onPremisesTotal / years,
                breakdown: this.onPremisesCosts
            },
            cloud: {
                total: cloudTotal,
                yearly: cloudTotal / years,
                breakdown: this.cloudCosts
            },
            comparison: {
                difference: cloudTotal - onPremisesTotal,
                percentage: ((cloudTotal - onPremisesTotal) / onPremisesTotal) * 100,
                recommendation: cloudTotal < onPremisesTotal ? 'Cloud is more cost-effective' : 'On-premises is more cost-effective'
            }
        };
    }
}

// Пример использования
const tcoCalculator = new TCOCalculator();

// On-premises costs (per year)
tcoCalculator.setOnPremisesCosts({
    hardware: 50000,
    software: 20000,
    maintenance: 15000,
    power: 5000,
    cooling: 3000,
    space: 10000,
    personnel: 80000,
    security: 10000,
    backup: 5000,
    disasterRecovery: 8000
});

// Cloud costs (per year)
tcoCalculator.setCloudCosts({
    compute: 30000,
    storage: 5000,
    networking: 2000,
    services: 8000,
    support: 5000,
    migration: 15000,
    training: 3000
});

const tco = tcoCalculator.calculateTCO(3);
console.log('TCO Comparison:', tco);
```

### 2. ROI Analysis
- Анализ возврата инвестиций
- Временные рамки
- Риски и возможности

### 3. Cost Optimization
- Постоянная оптимизация
- Автоматизация процессов
- Мониторинг затрат

## Best Practices

### 1. Cost Monitoring
- Регулярный мониторинг затрат
- Алерты при превышении бюджета
- Анализ трендов

### 2. Resource Optimization
- Right-sizing ресурсов
- Автоматическое масштабирование
- Удаление неиспользуемых ресурсов

### 3. Budget Management
- Установка бюджетных лимитов
- Контроль расходов
- Планирование затрат

### 4. Cost Allocation
- Тегирование ресурсов
- Центры затрат
- Отчетность по подразделениям