# Модуль 8: Облачные технологии и миграция

## Содержание модуля
1. [Основы облачных технологий](#основы-облачных-технологий)
2. [AWS (Amazon Web Services)](#aws-amazon-web-services)
3. [Azure (Microsoft Azure)](#azure-microsoft-azure)
4. [GCP (Google Cloud Platform)](#gcp-google-cloud-platform)
5. [Cloud-Native архитектура](#cloud-native-архитектура)
6. [Стратегии миграции](#стратегии-миграции)
7. [Cost Optimization](#cost-optimization)

---

## Основы облачных технологий

### Что такое облачные вычисления

**Облачные вычисления** — модель предоставления вычислительных ресурсов через интернет по требованию.

### Модели обслуживания

#### 1. IaaS (Infrastructure as a Service)
**Определение:** Предоставление виртуальной инфраструктуры.

**Примеры:**
- AWS EC2
- Azure Virtual Machines
- Google Compute Engine

**Преимущества:**
- Полный контроль над инфраструктурой
- Гибкость в выборе ОС и ПО
- Масштабируемость

**Технический пример - AWS EC2 Infrastructure as Code:**

```yaml
# terraform/main.tf
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = var.aws_region
}

# VPC Configuration
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name = "${var.project_name}-vpc"
    Environment = var.environment
  }
}

# Internet Gateway
resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name = "${var.project_name}-igw"
  }
}

# Public Subnets
resource "aws_subnet" "public" {
  count = length(var.availability_zones)

  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.${count.index + 1}.0/24"
  availability_zone       = var.availability_zones[count.index]
  map_public_ip_on_launch = true

  tags = {
    Name = "${var.project_name}-public-subnet-${count.index + 1}"
    Type = "Public"
  }
}

# Private Subnets
resource "aws_subnet" "private" {
  count = length(var.availability_zones)

  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.${count.index + 10}.0/24"
  availability_zone = var.availability_zones[count.index]

  tags = {
    Name = "${var.project_name}-private-subnet-${count.index + 1}"
    Type = "Private"
  }
}

# Security Groups
resource "aws_security_group" "web" {
  name_prefix = "${var.project_name}-web-"
  vpc_id      = aws_vpc.main.id

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = [var.admin_cidr]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name = "${var.project_name}-web-sg"
  }
}

resource "aws_security_group" "app" {
  name_prefix = "${var.project_name}-app-"
  vpc_id      = aws_vpc.main.id

  ingress {
    from_port       = 8080
    to_port         = 8080
    protocol        = "tcp"
    security_groups = [aws_security_group.web.id]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = [var.admin_cidr]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name = "${var.project_name}-app-sg"
  }
}

# Application Load Balancer
resource "aws_lb" "main" {
  name               = "${var.project_name}-alb"
  internal           = false
  load_balancer_type = "application"
  security_groups    = [aws_security_group.web.id]
  subnets            = aws_subnet.public[*].id

  enable_deletion_protection = false

  tags = {
    Name = "${var.project_name}-alb"
  }
}

# Target Group
resource "aws_lb_target_group" "app" {
  name     = "${var.project_name}-tg"
  port     = 8080
  protocol = "HTTP"
  vpc_id   = aws_vpc.main.id

  health_check {
    enabled             = true
    healthy_threshold   = 2
    unhealthy_threshold = 2
    timeout             = 5
    interval            = 30
    path                = "/health"
    matcher             = "200"
    port                = "traffic-port"
    protocol            = "HTTP"
  }

  tags = {
    Name = "${var.project_name}-tg"
  }
}

# Launch Template
resource "aws_launch_template" "app" {
  name_prefix   = "${var.project_name}-"
  image_id      = var.ami_id
  instance_type = var.instance_type

  vpc_security_group_ids = [aws_security_group.app.id]

  user_data = base64encode(templatefile("${path.module}/user_data.sh", {
    app_name = var.project_name
    environment = var.environment
  }))

  tag_specifications {
    resource_type = "instance"
    tags = {
      Name = "${var.project_name}-instance"
      Environment = var.environment
    }
  }

  lifecycle {
    create_before_destroy = true
  }
}

# Auto Scaling Group
resource "aws_autoscaling_group" "app" {
  name                = "${var.project_name}-asg"
  vpc_zone_identifier = aws_subnet.private[*].id
  target_group_arns   = [aws_lb_target_group.app.arn]
  health_check_type   = "ELB"
  health_check_grace_period = 300

  min_size         = var.min_size
  max_size         = var.max_size
  desired_capacity = var.desired_capacity

  launch_template {
    id      = aws_launch_template.app.id
    version = "$Latest"
  }

  tag {
    key                 = "Name"
    value               = "${var.project_name}-asg"
    propagate_at_launch = false
  }

  tag {
    key                 = "Environment"
    value               = var.environment
    propagate_at_launch = true
  }
}

# Auto Scaling Policies
resource "aws_autoscaling_policy" "scale_up" {
  name                   = "${var.project_name}-scale-up"
  scaling_adjustment     = 1
  adjustment_type        = "ChangeInCapacity"
  cooldown               = 300
  autoscaling_group_name = aws_autoscaling_group.app.name
}

resource "aws_autoscaling_policy" "scale_down" {
  name                   = "${var.project_name}-scale-down"
  scaling_adjustment     = -1
  adjustment_type        = "ChangeInCapacity"
  cooldown               = 300
  autoscaling_group_name = aws_autoscaling_group.app.name
}

# CloudWatch Alarms
resource "aws_cloudwatch_metric_alarm" "cpu_high" {
  alarm_name          = "${var.project_name}-cpu-high"
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = "2"
  metric_name         = "CPUUtilization"
  namespace           = "AWS/EC2"
  period              = "300"
  statistic           = "Average"
  threshold           = "80"
  alarm_description   = "This metric monitors ec2 cpu utilization"
  alarm_actions       = [aws_autoscaling_policy.scale_up.arn]

  dimensions = {
    AutoScalingGroupName = aws_autoscaling_group.app.name
  }
}

resource "aws_cloudwatch_metric_alarm" "cpu_low" {
  alarm_name          = "${var.project_name}-cpu-low"
  comparison_operator = "LessThanThreshold"
  evaluation_periods  = "2"
  metric_name         = "CPUUtilization"
  namespace           = "AWS/EC2"
  period              = "300"
  statistic           = "Average"
  threshold           = "20"
  alarm_description   = "This metric monitors ec2 cpu utilization"
  alarm_actions       = [aws_autoscaling_policy.scale_down.arn]

  dimensions = {
    AutoScalingGroupName = aws_autoscaling_group.app.name
  }
}

# RDS Database
resource "aws_db_subnet_group" "main" {
  name       = "${var.project_name}-db-subnet-group"
  subnet_ids = aws_subnet.private[*].id

  tags = {
    Name = "${var.project_name}-db-subnet-group"
  }
}

resource "aws_db_instance" "main" {
  identifier = "${var.project_name}-db"

  engine         = "postgres"
  engine_version = "14.7"
  instance_class = var.db_instance_class

  allocated_storage     = 20
  max_allocated_storage = 100
  storage_type          = "gp2"
  storage_encrypted     = true

  db_name  = var.db_name
  username = var.db_username
  password = var.db_password

  vpc_security_group_ids = [aws_security_group.db.id]
  db_subnet_group_name   = aws_db_subnet_group.main.name

  backup_retention_period = 7
  backup_window          = "03:00-04:00"
  maintenance_window     = "sun:04:00-sun:05:00"

  skip_final_snapshot = var.environment != "production"

  tags = {
    Name = "${var.project_name}-db"
    Environment = var.environment
  }
}

resource "aws_security_group" "db" {
  name_prefix = "${var.project_name}-db-"
  vpc_id      = aws_vpc.main.id

  ingress {
    from_port       = 5432
    to_port         = 5432
    protocol        = "tcp"
    security_groups = [aws_security_group.app.id]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name = "${var.project_name}-db-sg"
  }
}
```

```bash
# user_data.sh
#!/bin/bash
yum update -y

# Install Docker
yum install -y docker
systemctl start docker
systemctl enable docker
usermod -a -G docker ec2-user

# Install Docker Compose
curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose

# Create application directory
mkdir -p /opt/${app_name}
cd /opt/${app_name}

# Create docker-compose.yml
cat > docker-compose.yml << EOF
version: '3.8'
services:
  app:
    image: ${app_name}:latest
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=${environment}
      - DB_HOST=${db_host}
      - DB_PORT=5432
      - DB_NAME=${db_name}
      - DB_USERNAME=${db_username}
      - DB_PASSWORD=${db_password}
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - app
    restart: unless-stopped
EOF

# Start application
docker-compose up -d

# Install CloudWatch agent
yum install -y amazon-cloudwatch-agent
cat > /opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json << EOF
{
  "metrics": {
    "namespace": "CWAgent",
    "metrics_collected": {
      "cpu": {
        "measurement": ["cpu_usage_idle", "cpu_usage_iowait", "cpu_usage_user", "cpu_usage_system"],
        "metrics_collection_interval": 60
      },
      "disk": {
        "measurement": ["used_percent"],
        "metrics_collection_interval": 60,
        "resources": ["*"]
      },
      "mem": {
        "measurement": ["mem_used_percent"],
        "metrics_collection_interval": 60
      }
    }
  }
}
EOF

/opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl \
  -a fetch-config \
  -m ec2 \
  -c file:/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json \
  -s
```

```hcl
# variables.tf
variable "aws_region" {
  description = "AWS region"
  type        = string
  default     = "us-west-2"
}

variable "project_name" {
  description = "Name of the project"
  type        = string
}

variable "environment" {
  description = "Environment name"
  type        = string
  default     = "dev"
}

variable "availability_zones" {
  description = "List of availability zones"
  type        = list(string)
  default     = ["us-west-2a", "us-west-2b", "us-west-2c"]
}

variable "admin_cidr" {
  description = "CIDR block for admin access"
  type        = string
  default     = "0.0.0.0/0"
}

variable "ami_id" {
  description = "AMI ID for EC2 instances"
  type        = string
  default     = "ami-0c02fb55956c7d316" # Amazon Linux 2
}

variable "instance_type" {
  description = "EC2 instance type"
  type        = string
  default     = "t3.medium"
}

variable "min_size" {
  description = "Minimum number of instances"
  type        = number
  default     = 2
}

variable "max_size" {
  description = "Maximum number of instances"
  type        = number
  default     = 10
}

variable "desired_capacity" {
  description = "Desired number of instances"
  type        = number
  default     = 3
}

variable "db_instance_class" {
  description = "RDS instance class"
  type        = string
  default     = "db.t3.micro"
}

variable "db_name" {
  description = "Database name"
  type        = string
}

variable "db_username" {
  description = "Database username"
  type        = string
}

variable "db_password" {
  description = "Database password"
  type        = string
  sensitive   = true
}
```

#### 2. PaaS (Platform as a Service)
**Определение:** Предоставление платформы для разработки приложений.

**Примеры:**
- AWS Elastic Beanstalk
- Azure App Service
- Google App Engine

**Преимущества:**
- Фокус на разработке приложений
- Автоматическое управление инфраструктурой
- Встроенные сервисы

**Технический пример - Azure App Service Deployment:**

```yaml
# azure-pipelines.yml
trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

variables:
  azureSubscription: 'your-subscription-id'
  appName: 'your-app-name'
  resourceGroupName: 'your-resource-group'
  location: 'West Europe'

stages:
- stage: Build
  displayName: Build stage
  jobs:
  - job: Build
    displayName: Build
    steps:
    - task: NodeTool@0
      inputs:
        versionSpec: '18.x'
      displayName: 'Install Node.js'

    - script: |
        npm install
        npm run build
      displayName: 'Install dependencies and build'

    - task: ArchiveFiles@2
      displayName: 'Archive files'
      inputs:
        rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
        includeRootFolder: false
        archiveType: zip
        archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
        replaceExistingArchive: true

    - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip
      artifact: drop

- stage: Deploy
  displayName: Deploy stage
  dependsOn: Build
  condition: succeeded()
  jobs:
  - deployment: Deploy
    displayName: Deploy
    environment: 'production'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            displayName: 'Azure Web App Deploy'
            inputs:
              azureSubscription: '$(azureSubscription)'
              appType: 'webApp'
              appName: '$(appName)'
              package: '$(Pipeline.Workspace)/drop/$(Build.BuildId).zip'
              deploymentMethod: 'zipDeploy'
```

```json
// azure-resources.json
{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "appName": {
      "type": "string",
      "defaultValue": "my-app",
      "metadata": {
        "description": "Name of the App Service"
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "Location for all resources"
      }
    },
    "sku": {
      "type": "string",
      "defaultValue": "S1",
      "allowedValues": [
        "F1",
        "D1",
        "B1",
        "B2",
        "B3",
        "S1",
        "S2",
        "S3",
        "P1",
        "P2",
        "P3",
        "P4"
      ],
      "metadata": {
        "description": "The pricing tier for the hosting plan"
      }
    },
    "nodeVersion": {
      "type": "string",
      "defaultValue": "18-lts",
      "metadata": {
        "description": "The version of Node.js to use"
      }
    }
  },
  "variables": {
    "hostingPlanName": "[concat(parameters('appName'), '-plan')]",
    "applicationInsightsName": "[concat(parameters('appName'), '-ai')]"
  },
  "resources": [
    {
      "type": "Microsoft.Web/serverfarms",
      "apiVersion": "2021-02-01",
      "name": "[variables('hostingPlanName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "[parameters('sku')]"
      },
      "kind": "linux",
      "properties": {
        "reserved": true
      }
    },
    {
      "type": "Microsoft.Web/sites",
      "apiVersion": "2021-02-01",
      "name": "[parameters('appName')]",
      "location": "[parameters('location')]",
      "dependsOn": [
        "[resourceId('Microsoft.Web/serverfarms', variables('hostingPlanName'))]"
      ],
      "kind": "app,linux",
      "properties": {
        "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', variables('hostingPlanName'))]",
        "siteConfig": {
          "linuxFxVersion": "[concat('NODE|', parameters('nodeVersion'))]",
          "appSettings": [
            {
              "name": "WEBSITE_NODE_DEFAULT_VERSION",
              "value": "[parameters('nodeVersion')]"
            },
            {
              "name": "WEBSITE_RUN_FROM_PACKAGE",
              "value": "1"
            }
          ]
        }
      }
    },
    {
      "type": "Microsoft.Insights/components",
      "apiVersion": "2020-02-02",
      "name": "[variables('applicationInsightsName')]",
      "location": "[parameters('location')]",
      "kind": "web",
      "properties": {
        "Application_Type": "web",
        "Request_Source": "rest"
      }
    }
  ],
  "outputs": {
    "appUrl": {
      "type": "string",
      "value": "[concat('https://', reference(resourceId('Microsoft.Web/sites', parameters('appName'))).defaultHostName)]"
    },
    "appServicePlanId": {
      "type": "string",
      "value": "[resourceId('Microsoft.Web/serverfarms', variables('hostingPlanName'))]"
    }
  }
}
```

```javascript
// app.js - Express.js application for Azure App Service
const express = require('express');
const path = require('path');
const cors = require('cors');
const helmet = require('helmet');
const compression = require('compression');
const rateLimit = require('express-rate-limit');

const app = express();
const PORT = process.env.PORT || 3000;

// Security middleware
app.use(helmet());
app.use(compression());

// Rate limiting
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // limit each IP to 100 requests per windowMs
  message: 'Too many requests from this IP, please try again later.'
});
app.use(limiter);

// CORS configuration
app.use(cors({
  origin: process.env.ALLOWED_ORIGINS?.split(',') || ['http://localhost:3000'],
  credentials: true
}));

// Body parsing middleware
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true, limit: '10mb' }));

// Static files
app.use(express.static(path.join(__dirname, 'public')));

// Health check endpoint
app.get('/health', (req, res) => {
  res.status(200).json({
    status: 'healthy',
    timestamp: new Date().toISOString(),
    uptime: process.uptime(),
    environment: process.env.NODE_ENV || 'development',
    version: process.env.npm_package_version || '1.0.0'
  });
});

// API routes
app.use('/api', require('./routes/api'));

// Error handling middleware
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({
    error: 'Something went wrong!',
    message: process.env.NODE_ENV === 'development' ? err.message : 'Internal server error'
  });
});

// 404 handler
app.use('*', (req, res) => {
  res.status(404).json({
    error: 'Not Found',
    message: 'The requested resource was not found'
  });
});

// Graceful shutdown
process.on('SIGTERM', () => {
  console.log('SIGTERM received, shutting down gracefully');
  server.close(() => {
    console.log('Process terminated');
  });
});

const server = app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
  console.log(`Environment: ${process.env.NODE_ENV || 'development'}`);
});

module.exports = app;
```

**Дополнительные Node.js примеры для облачных технологий:**

**Node.js приложение для AWS Lambda:**
```typescript
// lambda/handler.ts
import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { DynamoDBDocumentClient, PutCommand, GetCommand } from '@aws-sdk/lib-dynamodb';

const dynamoClient = new DynamoDBClient({ region: process.env.AWS_REGION });
const docClient = DynamoDBDocumentClient.from(dynamoClient);

interface User {
  id: string;
  name: string;
  email: string;
  createdAt: string;
}

export const handler = async (
  event: APIGatewayProxyEvent,
  context: Context
): Promise<APIGatewayProxyResult> => {
  console.log('Event:', JSON.stringify(event, null, 2));
  console.log('Context:', JSON.stringify(context, null, 2));

  try {
    const method = event.httpMethod;
    const path = event.path;

    switch (method) {
      case 'POST':
        if (path === '/users') {
          return await createUser(event);
        }
        break;
      case 'GET':
        if (path.startsWith('/users/')) {
          const userId = path.split('/')[2];
          return await getUser(userId);
        }
        break;
      default:
        return {
          statusCode: 405,
          body: JSON.stringify({ error: 'Method not allowed' })
        };
    }

    return {
      statusCode: 404,
      body: JSON.stringify({ error: 'Not found' })
    };
  } catch (error) {
    console.error('Error:', error);
    return {
      statusCode: 500,
      body: JSON.stringify({ error: 'Internal server error' })
    };
  }
};

async function createUser(event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> {
  if (!event.body) {
    return {
      statusCode: 400,
      body: JSON.stringify({ error: 'Request body is required' })
    };
  }

  const userData = JSON.parse(event.body);
  const user: User = {
    id: generateId(),
    name: userData.name,
    email: userData.email,
    createdAt: new Date().toISOString()
  };

  await docClient.send(new PutCommand({
    TableName: process.env.USERS_TABLE,
    Item: user
  }));

  return {
    statusCode: 201,
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*'
    },
    body: JSON.stringify(user)
  };
}

async function getUser(userId: string): Promise<APIGatewayProxyResult> {
  const result = await docClient.send(new GetCommand({
    TableName: process.env.USERS_TABLE,
    Key: { id: userId }
  }));

  if (!result.Item) {
    return {
      statusCode: 404,
      body: JSON.stringify({ error: 'User not found' })
    };
  }

  return {
    statusCode: 200,
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*'
    },
    body: JSON.stringify(result.Item)
  };
}

function generateId(): string {
  return Math.random().toString(36).substr(2, 9);
}
```

**Node.js приложение для Google Cloud Functions:**
```typescript
// functions/index.ts
import { Request, Response } from 'express';
import { Storage } from '@google-cloud/storage';
import { Firestore } from '@google-cloud/firestore';

const storage = new Storage();
const firestore = new Firestore();

interface FileUploadRequest extends Request {
  file?: Express.Multer.File;
}

export const uploadFile = async (req: FileUploadRequest, res: Response): Promise<void> => {
  try {
    if (!req.file) {
      res.status(400).json({ error: 'No file uploaded' });
      return;
    }

    const bucketName = process.env.BUCKET_NAME;
    const fileName = `${Date.now()}-${req.file.originalname}`;
    
    // Upload to Google Cloud Storage
    const bucket = storage.bucket(bucketName!);
    const file = bucket.file(fileName);
    
    await file.save(req.file.buffer, {
      metadata: {
        contentType: req.file.mimetype,
        metadata: {
          originalName: req.file.originalname,
          uploadedBy: req.body.userId || 'anonymous'
        }
      }
    });

    // Save metadata to Firestore
    const fileMetadata = {
      fileName,
      originalName: req.file.originalname,
      size: req.file.size,
      contentType: req.file.mimetype,
      uploadedAt: new Date(),
      uploadedBy: req.body.userId || 'anonymous',
      downloadUrl: `https://storage.googleapis.com/${bucketName}/${fileName}`
    };

    await firestore.collection('files').add(fileMetadata);

    res.status(200).json({
      message: 'File uploaded successfully',
      file: fileMetadata
    });
  } catch (error) {
    console.error('Upload error:', error);
    res.status(500).json({ error: 'Upload failed' });
  }
};

export const getFiles = async (req: Request, res: Response): Promise<void> => {
  try {
    const userId = req.query.userId as string;
    let query = firestore.collection('files').orderBy('uploadedAt', 'desc');

    if (userId) {
      query = query.where('uploadedBy', '==', userId);
    }

    const snapshot = await query.limit(50).get();
    const files = snapshot.docs.map(doc => ({
      id: doc.id,
      ...doc.data()
    }));

    res.status(200).json({ files });
  } catch (error) {
    console.error('Get files error:', error);
    res.status(500).json({ error: 'Failed to retrieve files' });
  }
};
```

**Node.js приложение для Azure Functions:**
```typescript
// azure-functions/index.ts
import { AzureFunction, Context, HttpRequest } from '@azure/functions';
import { CosmosClient } from '@azure/cosmos';

const cosmosClient = new CosmosClient({
  endpoint: process.env.COSMOS_DB_ENDPOINT!,
  key: process.env.COSMOS_DB_KEY!
});

const database = cosmosClient.database(process.env.COSMOS_DB_NAME!);
const container = database.container('orders');

interface Order {
  id: string;
  userId: string;
  items: OrderItem[];
  total: number;
  status: string;
  createdAt: string;
}

interface OrderItem {
  productId: string;
  quantity: number;
  price: number;
}

export const httpTrigger: AzureFunction = async (
  context: Context,
  req: HttpRequest
): Promise<void> => {
  context.log('HTTP trigger function processed a request.');

  try {
    const method = req.method;
    const orderId = req.params.id;

    switch (method) {
      case 'POST':
        await createOrder(context, req);
        break;
      case 'GET':
        if (orderId) {
          await getOrder(context, orderId);
        } else {
          await getOrders(context, req);
        }
        break;
      case 'PUT':
        await updateOrder(context, orderId, req);
        break;
      default:
        context.res = {
          status: 405,
          body: { error: 'Method not allowed' }
        };
    }
  } catch (error) {
    context.log.error('Error:', error);
    context.res = {
      status: 500,
      body: { error: 'Internal server error' }
    };
  }
};

async function createOrder(context: Context, req: HttpRequest): Promise<void> {
  const orderData = req.body;
  
  const order: Order = {
    id: generateId(),
    userId: orderData.userId,
    items: orderData.items,
    total: orderData.items.reduce((sum: number, item: OrderItem) => sum + (item.price * item.quantity), 0),
    status: 'pending',
    createdAt: new Date().toISOString()
  };

  await container.items.create(order);

  context.res = {
    status: 201,
    headers: {
      'Content-Type': 'application/json'
    },
    body: order
  };
}

async function getOrder(context: Context, orderId: string): Promise<void> {
  const { resource: order } = await container.item(orderId, orderId).read();

  if (!order) {
    context.res = {
      status: 404,
      body: { error: 'Order not found' }
    };
    return;
  }

  context.res = {
    status: 200,
    headers: {
      'Content-Type': 'application/json'
    },
    body: order
  };
}

async function getOrders(context: Context, req: HttpRequest): Promise<void> {
  const userId = req.query.userId;
  let query = 'SELECT * FROM c';

  if (userId) {
    query += ` WHERE c.userId = "${userId}"`;
  }

  query += ' ORDER BY c.createdAt DESC';

  const { resources: orders } = await container.items.query(query).fetchAll();

  context.res = {
    status: 200,
    headers: {
      'Content-Type': 'application/json'
    },
    body: { orders }
  };
}

async function updateOrder(context: Context, orderId: string, req: HttpRequest): Promise<void> {
  const { resource: existingOrder } = await container.item(orderId, orderId).read();

  if (!existingOrder) {
    context.res = {
      status: 404,
      body: { error: 'Order not found' }
    };
    return;
  }

  const updatedOrder = {
    ...existingOrder,
    ...req.body,
    updatedAt: new Date().toISOString()
  };

  await container.item(orderId, orderId).replace(updatedOrder);

  context.res = {
    status: 200,
    headers: {
      'Content-Type': 'application/json'
    },
    body: updatedOrder
  };
}

function generateId(): string {
  return Math.random().toString(36).substr(2, 9);
}
```

**Terraform для Node.js приложения на AWS:**
```hcl
# terraform/main.tf
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = var.aws_region
}

# VPC
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name = "${var.project_name}-vpc"
  }
}

# Internet Gateway
resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name = "${var.project_name}-igw"
  }
}

# Public Subnets
resource "aws_subnet" "public" {
  count             = 2
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.${count.index + 1}.0/24"
  availability_zone = data.aws_availability_zones.available.names[count.index]

  map_public_ip_on_launch = true

  tags = {
    Name = "${var.project_name}-public-subnet-${count.index + 1}"
  }
}

# Private Subnets
resource "aws_subnet" "private" {
  count             = 2
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.${count.index + 10}.0/24"
  availability_zone = data.aws_availability_zones.available.names[count.index]

  tags = {
    Name = "${var.project_name}-private-subnet-${count.index + 1}"
  }
}

# Application Load Balancer
resource "aws_lb" "main" {
  name               = "${var.project_name}-alb"
  internal           = false
  load_balancer_type = "application"
  security_groups    = [aws_security_group.alb.id]
  subnets            = aws_subnet.public[*].id

  enable_deletion_protection = false

  tags = {
    Name = "${var.project_name}-alb"
  }
}

# ALB Target Group
resource "aws_lb_target_group" "app" {
  name     = "${var.project_name}-tg"
  port     = 3000
  protocol = "HTTP"
  vpc_id   = aws_vpc.main.id

  health_check {
    enabled             = true
    healthy_threshold   = 2
    interval            = 30
    matcher             = "200"
    path                = "/health"
    port                = "traffic-port"
    protocol            = "HTTP"
    timeout             = 5
    unhealthy_threshold = 2
  }

  tags = {
    Name = "${var.project_name}-tg"
  }
}

# ECS Cluster
resource "aws_ecs_cluster" "main" {
  name = "${var.project_name}-cluster"

  setting {
    name  = "containerInsights"
    value = "enabled"
  }

  tags = {
    Name = "${var.project_name}-cluster"
  }
}

# ECS Task Definition
resource "aws_ecs_task_definition" "app" {
  family                   = "${var.project_name}-app"
  network_mode             = "awsvpc"
  requires_compatibilities = ["FARGATE"]
  cpu                      = 256
  memory                   = 512
  execution_role_arn       = aws_iam_role.ecs_execution_role.arn
  task_role_arn           = aws_iam_role.ecs_task_role.arn

  container_definitions = jsonencode([
    {
      name  = "${var.project_name}-app"
      image = "${var.aws_account_id}.dkr.ecr.${var.aws_region}.amazonaws.com/${var.project_name}:latest"
      
      portMappings = [
        {
          containerPort = 3000
          protocol      = "tcp"
        }
      ]

      environment = [
        {
          name  = "NODE_ENV"
          value = "production"
        },
        {
          name  = "PORT"
          value = "3000"
        }
      ]

      secrets = [
        {
          name      = "DATABASE_URL"
          valueFrom = aws_secretsmanager_secret.database_url.arn
        }
      ]

      logConfiguration = {
        logDriver = "awslogs"
        options = {
          awslogs-group         = aws_cloudwatch_log_group.app.name
          awslogs-region        = var.aws_region
          awslogs-stream-prefix = "ecs"
        }
      }
    }
  ])

  tags = {
    Name = "${var.project_name}-task-definition"
  }
}

# ECS Service
resource "aws_ecs_service" "app" {
  name            = "${var.project_name}-service"
  cluster         = aws_ecs_cluster.main.id
  task_definition = aws_ecs_task_definition.app.arn
  desired_count   = 2
  launch_type     = "FARGATE"

  network_configuration {
    security_groups  = [aws_security_group.ecs_tasks.id]
    subnets          = aws_subnet.private[*].id
    assign_public_ip = false
  }

  load_balancer {
    target_group_arn = aws_lb_target_group.app.arn
    container_name   = "${var.project_name}-app"
    container_port   = 3000
  }

  depends_on = [aws_lb_listener.app]

  tags = {
    Name = "${var.project_name}-service"
  }
}

# RDS PostgreSQL
resource "aws_db_instance" "main" {
  identifier = "${var.project_name}-db"

  engine         = "postgres"
  engine_version = "15.4"
  instance_class = "db.t3.micro"

  allocated_storage     = 20
  max_allocated_storage = 100
  storage_type          = "gp2"
  storage_encrypted     = true

  db_name  = var.database_name
  username = var.database_username
  password = var.database_password

  vpc_security_group_ids = [aws_security_group.rds.id]
  db_subnet_group_name   = aws_db_subnet_group.main.name

  backup_retention_period = 7
  backup_window          = "03:00-04:00"
  maintenance_window     = "sun:04:00-sun:05:00"

  skip_final_snapshot = true

  tags = {
    Name = "${var.project_name}-db"
  }
}

# CloudWatch Log Group
resource "aws_cloudwatch_log_group" "app" {
  name              = "/ecs/${var.project_name}"
  retention_in_days = 30

  tags = {
    Name = "${var.project_name}-log-group"
  }
}

# Secrets Manager
resource "aws_secretsmanager_secret" "database_url" {
  name = "${var.project_name}-database-url"

  tags = {
    Name = "${var.project_name}-database-url"
  }
}

resource "aws_secretsmanager_secret_version" "database_url" {
  secret_id = aws_secretsmanager_secret.database_url.id
  secret_string = "postgresql://${var.database_username}:${var.database_password}@${aws_db_instance.main.endpoint}/${var.database_name}"
}
```

```yaml
# docker-compose.yml for local development
version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
      - PORT=3000
      - ALLOWED_ORIGINS=http://localhost:3000,http://localhost:3001
    volumes:
      - .:/app
      - /app/node_modules
    depends_on:
      - redis
      - postgres

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

  postgres:
    image: postgres:15-alpine
    environment:
      - POSTGRES_DB=myapp
      - POSTGRES_USER=myapp
      - POSTGRES_PASSWORD=myapp
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  redis_data:
  postgres_data:
```

```dockerfile
# Dockerfile
FROM node:18-alpine AS builder

WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production && npm cache clean --force

# Copy source code
COPY . .

# Build application
RUN npm run build

# Production stage
FROM node:18-alpine AS production

WORKDIR /app

# Create non-root user
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001

# Copy built application
COPY --from=builder --chown=nextjs:nodejs /app .

# Switch to non-root user
USER nextjs

# Expose port
EXPOSE 3000

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD node healthcheck.js

# Start application
CMD ["npm", "start"]
```

```javascript
// healthcheck.js
const http = require('http');

const options = {
  hostname: 'localhost',
  port: process.env.PORT || 3000,
  path: '/health',
  method: 'GET',
  timeout: 2000
};

const req = http.request(options, (res) => {
  if (res.statusCode === 200) {
    process.exit(0);
  } else {
    process.exit(1);
  }
});

req.on('error', () => {
  process.exit(1);
});

req.on('timeout', () => {
  req.destroy();
  process.exit(1);
});

req.end();
```

#### 3. SaaS (Software as a Service)
**Определение:** Предоставление готового программного обеспечения.

**Примеры:**
- Salesforce
- Microsoft Office 365
- Google Workspace

**Преимущества:**
- Готовое решение
- Нет необходимости в разработке
- Автоматические обновления

### Модели развертывания

#### 1. Public Cloud
**Определение:** Облачные ресурсы, доступные публично.

**Характеристики:**
- Общие ресурсы
- Оплата по использованию
- Высокая масштабируемость

#### 2. Private Cloud
**Определение:** Облачные ресурсы для одной организации.

**Характеристики:**
- Изолированные ресурсы
- Высокий уровень безопасности
- Полный контроль

#### 3. Hybrid Cloud
**Определение:** Комбинация публичного и приватного облака.

**Характеристики:**
- Гибкость в выборе
- Оптимизация затрат
- Сложность управления

#### 4. Multi-Cloud
**Определение:** Использование нескольких облачных провайдеров.

**Характеристики:**
- Избежание vendor lock-in
- Оптимизация по сервисам
- Высокая сложность

---

## AWS (Amazon Web Services)

### Основные сервисы AWS

#### 1. Compute Services

**EC2 (Elastic Compute Cloud)**
- Виртуальные серверы в облаке
- Различные типы инстансов (t3, m5, c5, r5, etc.)
- Автомасштабирование с Auto Scaling Groups
- Spot Instances для экономии

```yaml
# EC2 Instance Configuration
Resources:
  WebServerInstance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: ami-0c02fb55956c7d316  # Amazon Linux 2
      InstanceType: t3.micro
      KeyName: my-key-pair
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash
          yum update -y
          yum install -y docker
          systemctl start docker
          systemctl enable docker
          usermod -a -G docker ec2-user
          docker run -d -p 80:80 nginx
      Tags:
        - Key: Name
          Value: WebServer
        - Key: Environment
          Value: Production
```

**Lambda (Serverless Computing)**
- Выполнение кода без управления серверами
- Оплата только за время выполнения
- Автоматическое масштабирование
- Интеграция с другими AWS сервисами

```python
# Lambda Function Example
import json
import boto3

def lambda_handler(event, context):
    """
    AWS Lambda function для обработки заказов
    """
    # Получение данных из события
    order_data = event.get('order', {})
    
    # Валидация данных
    if not validate_order(order_data):
        return {
            'statusCode': 400,
            'body': json.dumps({'error': 'Invalid order data'})
        }
    
    # Обработка заказа
    order_id = process_order(order_data)
    
    # Отправка уведомления через SNS
    sns = boto3.client('sns')
    sns.publish(
        TopicArn='arn:aws:sns:us-east-1:123456789012:order-notifications',
        Message=f'Order {order_id} has been processed',
        Subject='Order Processed'
    )
    
    return {
        'statusCode': 200,
        'body': json.dumps({
            'orderId': order_id,
            'status': 'processed'
        })
    }

def validate_order(order_data):
    """Валидация данных заказа"""
    required_fields = ['customerId', 'items', 'total']
    return all(field in order_data for field in required_fields)

def process_order(order_data):
    """Обработка заказа"""
    # Логика обработки заказа
    return f"ORD-{order_data.get('customerId')}-{int(time.time())}"
```

**Elastic Beanstalk**
- Платформа для развертывания приложений
- Автоматическое управление инфраструктурой
- Поддержка различных языков и фреймворков

```yaml
# Elastic Beanstalk Configuration
Resources:
  WebAppEnvironment:
    Type: AWS::ElasticBeanstalk::Environment
    Properties:
      ApplicationName: !Ref WebApplication
      EnvironmentName: !Sub "${AWS::StackName}-env"
      SolutionStackName: "64bit Amazon Linux 2 v3.4.0 running Docker"
      VersionLabel: !Ref ApplicationVersion
      OptionSettings:
        - Namespace: aws:autoscaling:launchconfiguration
          OptionName: InstanceType
          Value: t3.micro
        - Namespace: aws:autoscaling:asg
          OptionName: MinSize
          Value: "1"
        - Namespace: aws:autoscaling:asg
          OptionName: MaxSize
          Value: "3"
```

#### 2. Storage Services
```yaml
# S3 Bucket Configuration
Resources:
  MyBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: my-app-bucket
      VersioningConfiguration:
        Status: Enabled
      PublicAccessBlockConfiguration:
        BlockPublicAcls: true
        BlockPublicPolicy: true
        IgnorePublicAcls: true
        RestrictPublicBuckets: true
```

#### 3. Database Services
```yaml
# RDS Configuration
Resources:
  MyDatabase:
    Type: AWS::RDS::DBInstance
    Properties:
      DBInstanceIdentifier: my-database
      DBInstanceClass: db.t3.micro
      Engine: postgres
      EngineVersion: "13.7"
      MasterUsername: admin
      MasterUserPassword: !Ref DatabasePassword
      AllocatedStorage: 20
      StorageType: gp2
      VPCSecurityGroups:
        - !Ref DatabaseSecurityGroup
```

#### 4. Networking Services
```yaml
# VPC Configuration
Resources:
  MyVPC:
    Type: AWS::EC2::VPC
    Properties:
      CidrBlock: 10.0.0.0/16
      EnableDnsHostnames: true
      EnableDnsSupport: true
      Tags:
        - Key: Name
          Value: MyVPC

  PublicSubnet:
    Type: AWS::EC2::Subnet
    Properties:
      VpcId: !Ref MyVPC
      CidrBlock: 10.0.1.0/24
      AvailabilityZone: !Select [0, !GetAZs '']
      MapPublicIpOnLaunch: true
```

### Лучшие практики AWS

#### 1. Security
```yaml
# IAM Role Configuration
Resources:
  EC2Role:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: ec2.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: S3Access
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - s3:GetObject
                  - s3:PutObject
                Resource: !Sub '${MyBucket}/*'
```

#### 2. Monitoring
```yaml
# CloudWatch Alarms
Resources:
  HighCPUAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmName: HighCPUUtilization
      AlarmDescription: Alarm when CPU exceeds 80%
      MetricName: CPUUtilization
      Namespace: AWS/EC2
      Statistic: Average
      Period: 300
      EvaluationPeriods: 2
      Threshold: 80
      ComparisonOperator: GreaterThanThreshold
      Dimensions:
        - Name: InstanceId
          Value: !Ref MyInstance
```

---

## Azure (Microsoft Azure)

### Основные сервисы Azure

#### 1. Compute Services
```yaml
# Azure VM Configuration
apiVersion: 2021-03-01
type: Microsoft.Compute/virtualMachines
properties:
  hardwareProfile:
    vmSize: Standard_B1s
  storageProfile:
    imageReference:
      publisher: Canonical
      offer: UbuntuServer
      sku: 18.04-LTS
      version: latest
    osDisk:
      createOption: FromImage
      managedDisk:
        storageAccountType: Standard_LRS
  osProfile:
    computerName: my-vm
    adminUsername: azureuser
    adminPassword: !Ref AdminPassword
  networkProfile:
    networkInterfaces:
      - id: !Ref NetworkInterface
```

#### 2. Storage Services
```yaml
# Azure Storage Account
apiVersion: 2021-02-01
type: Microsoft.Storage/storageAccounts
properties:
  sku:
    name: Standard_LRS
  kind: StorageV2
  accessTier: Hot
  supportsHttpsTrafficOnly: true
  minimumTlsVersion: TLS1_2
  allowBlobPublicAccess: false
```

#### 3. Database Services
```yaml
# Azure SQL Database
apiVersion: 2021-02-01
type: Microsoft.Sql/servers
properties:
  administratorLogin: admin
  administratorLoginPassword: !Ref AdminPassword
  version: 12.0
  publicNetworkAccess: Disabled
  minimalTlsVersion: 1.2
```

#### 4. Networking Services
```yaml
# Azure Virtual Network
apiVersion: 2021-02-01
type: Microsoft.Network/virtualNetworks
properties:
  addressSpace:
    addressPrefixes:
      - 10.0.0.0/16
  subnets:
    - name: default
      properties:
        addressPrefix: 10.0.1.0/24
```

### Лучшие практики Azure

#### 1. Resource Groups
```yaml
# Resource Group Organization
Resources:
  ProductionRG:
    Type: Microsoft.Resources/resourceGroups
    Properties:
      location: East US
      tags:
        Environment: Production
        CostCenter: IT
        Owner: Development Team

  DevelopmentRG:
    Type: Microsoft.Resources/resourceGroups
    Properties:
      location: East US
      tags:
        Environment: Development
        CostCenter: IT
        Owner: Development Team
```

#### 2. Monitoring
```yaml
# Azure Monitor Alerts
Resources:
  HighCPUAlert:
    Type: Microsoft.Insights/metricAlerts
    Properties:
      description: Alert when CPU exceeds 80%
      severity: 2
      enabled: true
      scopes:
        - !Ref VirtualMachine
      criteria:
        metricName: Percentage CPU
        operator: GreaterThan
        threshold: 80
        timeAggregation: Average
```

---

## GCP (Google Cloud Platform)

### Основные сервисы GCP

#### 1. Compute Services
```yaml
# GCP VM Instance
resources:
- name: my-vm
  type: compute.v1.instance
  properties:
    zone: us-central1-a
    machineType: zones/us-central1-a/machineTypes/e2-micro
    disks:
    - deviceName: boot
      type: PERSISTENT
      boot: true
      autoDelete: true
      initializeParams:
        sourceImage: projects/ubuntu-os-cloud/global/images/family/ubuntu-2004-lts
    networkInterfaces:
    - network: global/networks/default
      accessConfigs:
      - name: External NAT
        type: ONE_TO_ONE_NAT
```

#### 2. Storage Services
```yaml
# GCP Cloud Storage Bucket
resources:
- name: my-bucket
  type: storage.v1.bucket
  properties:
    location: US
    storageClass: STANDARD
    versioning:
      enabled: true
    lifecycle:
      rule:
      - action:
          type: Delete
        condition:
          age: 365
```

#### 3. Database Services
```yaml
# GCP Cloud SQL
resources:
- name: my-database
  type: sqladmin.v1beta4.instance
  properties:
    region: us-central1
    settings:
      tier: db-f1-micro
      dataDiskType: PD_SSD
      dataDiskSizeGb: 10
      backupConfiguration:
        enabled: true
        startTime: 03:00
      ipConfiguration:
        ipv4Enabled: true
        authorizedNetworks:
        - value: 0.0.0.0/0
```

#### 4. Networking Services
```yaml
# GCP VPC Network
resources:
- name: my-vpc
  type: compute.v1.network
  properties:
    autoCreateSubnetworks: false
    routingConfig:
      routingMode: REGIONAL

- name: my-subnet
  type: compute.v1.subnetwork
  properties:
    network: $(ref.my-vpc.selfLink)
    ipCidrRange: 10.0.0.0/24
    region: us-central1
```

### Лучшие практики GCP

#### 1. IAM
```yaml
# GCP IAM Policy
resources:
- name: my-iam-policy
  type: gcp-types/cloudresourcemanager-v1:projects.iamPolicyBinding
  properties:
    resource: projects/my-project
    role: roles/storage.objectViewer
    members:
    - user:user@example.com
    - serviceAccount:service@project.iam.gserviceaccount.com
```

#### 2. Monitoring
```yaml
# GCP Monitoring Alert
resources:
- name: high-cpu-alert
  type: monitoring.v3.alertPolicy
  properties:
    displayName: High CPU Usage
    conditions:
    - displayName: CPU usage is high
      conditionThreshold:
        filter: 'resource.type="gce_instance"'
        comparison: COMPARISON_GREATER_THAN
        thresholdValue: 0.8
        duration: 300s
    alertStrategy:
      autoClose: 1800s
```

---

## Cloud-Native архитектура

### Принципы Cloud-Native

#### 1. 12-Factor App
```markdown
# 12-Factor App Principles

1. **Codebase** — один код, множество развертываний
2. **Dependencies** — явно объявлять и изолировать зависимости
3. **Config** — хранить конфигурацию в переменных окружения
4. **Backing Services** — рассматривать внешние сервисы как подключенные ресурсы
5. **Build, Release, Run** — строго разделять этапы сборки и выполнения
6. **Processes** — выполнять приложение как один или несколько stateless процессов
7. **Port Binding** — экспортировать сервисы через привязку к порту
8. **Concurrency** — масштабировать через модель процессов
9. **Disposability** — максимизировать надежность через быстрый запуск и graceful shutdown
10. **Dev/Prod Parity** — держать разработку, staging и production максимально похожими
11. **Logs** — рассматривать логи как потоки событий
12. **Admin Processes** — выполнять административные задачи как одноразовые процессы
```

#### 2. Microservices Architecture
```yaml
# Kubernetes Microservices Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: user-service:latest
        ports:
        - containerPort: 8080
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: database-secret
              key: url
        - name: REDIS_URL
          valueFrom:
            configMapKeyRef:
              name: redis-config
              key: url
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
```

#### 3. Container Orchestration
```yaml
# Kubernetes Service
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
  type: ClusterIP

---
# Kubernetes Ingress
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: user-service-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: api.example.com
    http:
      paths:
      - path: /users
        pathType: Prefix
        backend:
          service:
            name: user-service
            port:
              number: 80
```

### Serverless архитектура

#### 1. AWS Lambda
```python
import json
import boto3

def lambda_handler(event, context):
    # Обработка события
    user_id = event['pathParameters']['id']
    
    # Получение данных пользователя
    dynamodb = boto3.resource('dynamodb')
    table = dynamodb.Table('Users')
    
    try:
        response = table.get_item(Key={'id': user_id})
        user = response['Item']
        
        return {
            'statusCode': 200,
            'body': json.dumps(user)
        }
    except Exception as e:
        return {
            'statusCode': 500,
            'body': json.dumps({'error': str(e)})
        }
```

#### 2. Azure Functions
```csharp
[FunctionName("GetUser")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", Route = "users/{id}")] HttpRequest req,
    string id,
    ILogger log)
{
    log.LogInformation($"Getting user with ID: {id}");
    
    try
    {
        var user = await userService.GetUserAsync(id);
        
        if (user == null)
        {
            return new NotFoundResult();
        }
        
        return new OkObjectResult(user);
    }
    catch (Exception ex)
    {
        log.LogError(ex, "Error getting user");
        return new StatusCodeResult(500);
    }
}
```

#### 3. Google Cloud Functions
```javascript
const { Firestore } = require('@google-cloud/firestore');

exports.getUser = async (req, res) => {
    const userId = req.params.id;
    
    try {
        const firestore = new Firestore();
        const doc = await firestore.collection('users').doc(userId).get();
        
        if (!doc.exists) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        res.json(doc.data());
    } catch (error) {
        console.error('Error getting user:', error);
        res.status(500).json({ error: 'Internal server error' });
    }
};
```

---

## Мультиоблачные и гибридные стратегии

### Мультиоблачная архитектура

**Мультиоблачная архитектура** — использование нескольких облачных провайдеров для различных сервисов или в качестве резервных копий.

#### Преимущества мультиоблачной стратегии

1. **Избежание vendor lock-in**
2. **Лучшие цены** за счет конкуренции
3. **Географическое распределение**
4. **Отказоустойчивость**
5. **Специализированные сервисы**

#### Архитектурные паттерны

```yaml
# Multi-Cloud Architecture
apiVersion: v1
kind: ConfigMap
metadata:
  name: multi-cloud-config
data:
  strategy: |
    primary_cloud: "AWS"
    secondary_cloud: "Azure"
    disaster_recovery: "GCP"
    
  services:
    - name: "user-service"
      cloud: "AWS"
      region: "us-east-1"
      backup_cloud: "Azure"
      
    - name: "payment-service"
      cloud: "Azure"
      region: "eastus"
      backup_cloud: "AWS"
      
    - name: "analytics-service"
      cloud: "GCP"
      region: "us-central1"
      backup_cloud: "AWS"
```

#### Реализация мультиоблачной стратегии

```python
# Multi-Cloud Service Manager
class MultiCloudManager:
    def __init__(self):
        self.aws_client = boto3.client('ec2')
        self.azure_client = get_azure_client()
        self.gcp_client = get_gcp_client()
        
        self.cloud_configs = {
            'aws': {
                'client': self.aws_client,
                'regions': ['us-east-1', 'us-west-2', 'eu-west-1'],
                'services': ['ec2', 's3', 'rds', 'lambda']
            },
            'azure': {
                'client': self.azure_client,
                'regions': ['eastus', 'westus2', 'westeurope'],
                'services': ['vm', 'storage', 'sql', 'functions']
            },
            'gcp': {
                'client': self.gcp_client,
                'regions': ['us-central1', 'us-east1', 'europe-west1'],
                'services': ['compute', 'storage', 'sql', 'cloud-functions']
            }
        }
    
    def deploy_service(self, service_name, service_config):
        """Развертывание сервиса в мультиоблачной среде"""
        primary_cloud = service_config.get('primary_cloud', 'aws')
        backup_cloud = service_config.get('backup_cloud')
        
        # Развертывание в основном облаке
        primary_result = self._deploy_to_cloud(
            primary_cloud, 
            service_name, 
            service_config
        )
        
        # Развертывание в резервном облаке
        if backup_cloud:
            backup_result = self._deploy_to_cloud(
                backup_cloud, 
                service_name, 
                service_config
            )
            
            return {
                'primary': primary_result,
                'backup': backup_result,
                'status': 'deployed'
            }
        
        return primary_result
    
    def _deploy_to_cloud(self, cloud_provider, service_name, config):
        """Развертывание сервиса в конкретном облаке"""
        cloud_config = self.cloud_configs[cloud_provider]
        
        if cloud_provider == 'aws':
            return self._deploy_aws_service(service_name, config)
        elif cloud_provider == 'azure':
            return self._deploy_azure_service(service_name, config)
        elif cloud_provider == 'gcp':
            return self._deploy_gcp_service(service_name, config)
    
    def _deploy_aws_service(self, service_name, config):
        """Развертывание в AWS"""
        # Создание EC2 инстанса
        response = self.aws_client.run_instances(
            ImageId=config.get('ami_id'),
            MinCount=1,
            MaxCount=1,
            InstanceType=config.get('instance_type', 't3.micro'),
            SecurityGroupIds=config.get('security_groups', []),
            TagSpecifications=[{
                'ResourceType': 'instance',
                'Tags': [
                    {'Key': 'Name', 'Value': service_name},
                    {'Key': 'Environment', 'Value': config.get('environment', 'production')}
                ]
            }]
        )
        
        return {
            'cloud': 'aws',
            'instance_id': response['Instances'][0]['InstanceId'],
            'status': 'running'
        }
```

### Гибридная облачная архитектура

**Гибридная облачная архитектура** — комбинация частного облака (on-premises) и публичного облака.

#### Архитектурные компоненты

```mermaid
graph TB
    subgraph "On-Premises Data Center"
        A[Private Cloud] --> B[Local Services]
        B --> C[Database]
        B --> D[File Storage]
    end
    
    subgraph "Public Cloud"
        E[Cloud Services] --> F[Web Applications]
        E --> G[Analytics]
        E --> H[Backup]
    end
    
    subgraph "Hybrid Connectivity"
        I[VPN/ExpressRoute] --> J[Load Balancer]
        J --> K[API Gateway]
    end
    
    A <--> I
    E <--> I
    K --> A
    K --> E
```

#### Гибридная интеграция

```java
// Hybrid Cloud Integration Service
@Service
public class HybridCloudService {
    
    @Autowired
    private OnPremisesService onPremisesService;
    
    @Autowired
    private CloudService cloudService;
    
    @Value("${hybrid.routing.strategy}")
    private String routingStrategy;
    
    public ResponseEntity<String> processRequest(String serviceType, Object request) {
        // Определение стратегии маршрутизации
        CloudProvider provider = determineProvider(serviceType, request);
        
        switch (provider) {
            case ON_PREMISES:
                return onPremisesService.process(request);
            case CLOUD:
                return cloudService.process(request);
            case HYBRID:
                return processHybrid(request);
            default:
                throw new IllegalArgumentException("Unknown provider: " + provider);
        }
    }
    
    private CloudProvider determineProvider(String serviceType, Object request) {
        // Логика определения провайдера
        if (routingStrategy.equals("data-locality")) {
            return determineByDataLocality(request);
        } else if (routingStrategy.equals("performance")) {
            return determineByPerformance(serviceType);
        } else if (routingStrategy.equals("cost")) {
            return determineByCost(serviceType);
        }
        
        return CloudProvider.CLOUD; // По умолчанию
    }
    
    private ResponseEntity<String> processHybrid(Object request) {
        // Обработка в гибридном режиме
        // Часть данных обрабатывается локально, часть в облаке
        
        // 1. Обработка чувствительных данных локально
        String sensitiveData = extractSensitiveData(request);
        String processedSensitiveData = onPremisesService.processSensitive(sensitiveData);
        
        // 2. Обработка остальных данных в облаке
        Object cloudRequest = prepareCloudRequest(request, processedSensitiveData);
        ResponseEntity<String> cloudResponse = cloudService.process(cloudRequest);
        
        // 3. Объединение результатов
        return combineResults(processedSensitiveData, cloudResponse);
    }
}
```

### Стратегии миграции

#### 1. Lift and Shift (Rehosting)

**Lift and Shift** — перенос приложения в облако без изменений архитектуры.

```yaml
# Lift and Shift Migration Plan
migration_plan:
  phase_1_assessment:
    - "Inventory current applications"
    - "Identify dependencies"
    - "Assess cloud readiness"
    - "Calculate migration costs"
  
  phase_2_preparation:
    - "Set up cloud infrastructure"
    - "Configure networking"
    - "Prepare security policies"
    - "Train team on cloud tools"
  
  phase_3_migration:
    - "Migrate non-critical applications first"
    - "Test in cloud environment"
    - "Migrate critical applications"
    - "Validate functionality"
  
  phase_4_optimization:
    - "Optimize for cloud-native features"
    - "Implement monitoring"
    - "Fine-tune performance"
    - "Cost optimization"
```

#### 2. Refactoring (Replatforming)

**Refactoring** — модификация приложения для использования облачных сервисов.

```java
// Before: On-premises application
@RestController
public class LegacyOrderController {
    
    @Autowired
    private FileSystemOrderService fileSystemService;
    
    @PostMapping("/orders")
    public ResponseEntity<Order> createOrder(@RequestBody Order order) {
        // Сохранение в файловую систему
        fileSystemService.saveOrder(order);
        return ResponseEntity.ok(order);
    }
}

// After: Cloud-native application
@RestController
public class CloudOrderController {
    
    @Autowired
    private DynamoDBOrderService dynamoDBService;
    
    @Autowired
    private S3DocumentService s3Service;
    
    @Autowired
    private SNSNotificationService notificationService;
    
    @PostMapping("/orders")
    public ResponseEntity<Order> createOrder(@RequestBody Order order) {
        // Сохранение в DynamoDB
        Order savedOrder = dynamoDBService.saveOrder(order);
        
        // Сохранение документов в S3
        s3Service.saveOrderDocuments(order);
        
        // Отправка уведомления через SNS
        notificationService.sendOrderCreatedNotification(savedOrder);
        
        return ResponseEntity.ok(savedOrder);
    }
}
```

#### 3. Re-architecting

**Re-architecting** — полная переработка приложения с использованием облачных паттернов.

```yaml
# Re-architecting Strategy
architecture_transformation:
  from_monolith:
    - "Single application"
    - "Tightly coupled components"
    - "Single database"
    - "Vertical scaling"
  
  to_microservices:
    - "Multiple independent services"
    - "Loosely coupled via APIs"
    - "Database per service"
    - "Horizontal scaling"
  
  cloud_native_patterns:
    - "Event-driven architecture"
    - "Serverless functions"
    - "Container orchestration"
    - "API Gateway"
    - "Service Mesh"
```

### Управление мультиоблачной средой

#### 1. Единая точка управления

```python
# Multi-Cloud Management Dashboard
class CloudManagementDashboard:
    def __init__(self):
        self.cloud_managers = {
            'aws': AWSManager(),
            'azure': AzureManager(),
            'gcp': GCPManager()
        }
    
    def get_unified_metrics(self):
        """Получение унифицированных метрик со всех облаков"""
        metrics = {}
        
        for cloud_name, manager in self.cloud_managers.items():
            metrics[cloud_name] = {
                'cost': manager.get_monthly_cost(),
                'usage': manager.get_resource_usage(),
                'performance': manager.get_performance_metrics(),
                'security': manager.get_security_status()
            }
        
        return self.aggregate_metrics(metrics)
    
    def optimize_costs(self):
        """Оптимизация затрат в мультиоблачной среде"""
        recommendations = []
        
        for cloud_name, manager in self.cloud_managers.items():
            cloud_recommendations = manager.get_cost_optimization_recommendations()
            recommendations.extend(cloud_recommendations)
        
        return self.prioritize_recommendations(recommendations)
    
    def disaster_recovery_plan(self):
        """План аварийного восстановления"""
        return {
            'rto': '4 hours',  # Recovery Time Objective
            'rpo': '1 hour',   # Recovery Point Objective
            'backup_strategy': 'Cross-cloud replication',
            'failover_procedure': self.get_failover_procedure()
        }
```

#### 2. Безопасность в мультиоблачной среде

```yaml
# Multi-Cloud Security Configuration
security:
  identity_management:
    primary: "Azure AD"
    federation:
      - "AWS IAM"
      - "GCP IAM"
  
  network_security:
    vpn_connections:
      - "AWS VPN Gateway"
      - "Azure VPN Gateway"
      - "GCP Cloud VPN"
    
    firewall_rules:
      - "AWS Security Groups"
      - "Azure NSG"
      - "GCP Firewall Rules"
  
  data_encryption:
    at_rest:
      - "AWS KMS"
      - "Azure Key Vault"
      - "GCP Cloud KMS"
    
    in_transit:
      - "TLS 1.3"
      - "IPSec"
      - "mTLS"
  
  compliance:
    standards:
      - "SOC 2"
      - "ISO 27001"
      - "GDPR"
      - "HIPAA"
```

### Сравнение стратегий

| Стратегия | Сложность | Время | Стоимость | Риск | Гибкость |
|-----------|-----------|-------|-----------|------|----------|
| **Lift and Shift** | Низкая | Быстро | Низкая | Низкий | Низкая |
| **Refactoring** | Средняя | Средне | Средняя | Средний | Средняя |
| **Re-architecting** | Высокая | Долго | Высокая | Высокий | Высокая |
| **Hybrid** | Очень высокая | Очень долго | Очень высокая | Очень высокий | Очень высокая |

---

## Стратегии миграции

### Типы миграции

#### 1. Lift and Shift (Rehosting)
**Определение:** Перенос приложения в облако без изменений.

**Преимущества:**
- Быстрая миграция
- Минимальные изменения
- Низкий риск

**Недостатки:**
- Не использует преимущества облака
- Высокие затраты
- Ограниченная масштабируемость

```yaml
# Lift and Shift Example
# Original on-premises application
# Migrated to AWS EC2
Resources:
  MyApplication:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: ami-0c02fb55956c7d316
      InstanceType: t3.large
      SecurityGroups:
        - !Ref ApplicationSecurityGroup
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash
          # Install application dependencies
          yum update -y
          yum install -y java-1.8.0-openjdk
          # Deploy application
          aws s3 cp s3://my-bucket/app.jar /opt/app.jar
          java -jar /opt/app.jar
```

#### 2. Replatforming
**Определение:** Миграция с минимальными изменениями для использования облачных сервисов.

**Преимущества:**
- Использование облачных сервисов
- Улучшенная производительность
- Снижение затрат

**Недостатки:**
- Требует изменений в приложении
- Средний риск
- Время на адаптацию

```yaml
# Replatforming Example
# Migrate from on-premises database to RDS
Resources:
  MyDatabase:
    Type: AWS::RDS::DBInstance
    Properties:
      DBInstanceIdentifier: my-app-db
      DBInstanceClass: db.t3.micro
      Engine: mysql
      EngineVersion: "8.0"
      MasterUsername: admin
      MasterUserPassword: !Ref DatabasePassword
      AllocatedStorage: 20
      VPCSecurityGroups:
        - !Ref DatabaseSecurityGroup

  MyApplication:
    Type: AWS::ECS::Service
    Properties:
      ServiceName: my-app-service
      Cluster: !Ref ECSCluster
      TaskDefinition: !Ref TaskDefinition
      DesiredCount: 2
```

#### 3. Refactoring (Re-architecting)
**Определение:** Полная переработка приложения для облачной архитектуры.

**Преимущества:**
- Максимальное использование облака
- Высокая масштабируемость
- Оптимальная производительность

**Недостатки:**
- Высокие затраты
- Длительное время
- Высокий риск

```yaml
# Refactoring Example
# Migrate to microservices architecture
Resources:
  UserService:
    Type: AWS::ECS::Service
    Properties:
      ServiceName: user-service
      Cluster: !Ref ECSCluster
      TaskDefinition: !Ref UserServiceTaskDefinition
      DesiredCount: 3

  OrderService:
    Type: AWS::ECS::Service
    Properties:
      ServiceName: order-service
      Cluster: !Ref ECSCluster
      TaskDefinition: !Ref OrderServiceTaskDefinition
      DesiredCount: 3

  APIGateway:
    Type: AWS::ApiGateway::RestApi
    Properties:
      Name: microservices-api
      Description: API Gateway for microservices
```

### Миграционная стратегия

#### 1. Assessment Phase
```markdown
# Assessment Checklist

## Application Analysis
- [ ] Inventory all applications
- [ ] Analyze dependencies
- [ ] Assess performance requirements
- [ ] Identify security requirements
- [ ] Calculate current costs

## Infrastructure Analysis
- [ ] Map network topology
- [ ] Identify data flows
- [ ] Assess storage requirements
- [ ] Analyze backup strategies
- [ ] Document disaster recovery

## Business Analysis
- [ ] Define migration goals
- [ ] Identify critical applications
- [ ] Assess business impact
- [ ] Plan migration timeline
- [ ] Allocate resources
```

#### 2. Planning Phase
```markdown
# Migration Plan

## Phase 1: Foundation (Month 1-2)
- Set up cloud infrastructure
- Configure networking
- Implement security controls
- Set up monitoring

## Phase 2: Pilot Migration (Month 3-4)
- Migrate non-critical applications
- Test cloud services
- Validate performance
- Train team

## Phase 3: Production Migration (Month 5-8)
- Migrate critical applications
- Implement disaster recovery
- Optimize performance
- Monitor and adjust

## Phase 4: Optimization (Month 9-12)
- Optimize costs
- Implement automation
- Enhance security
- Continuous improvement
```

#### 3. Execution Phase
```yaml
# Migration Automation
Resources:
  MigrationPipeline:
    Type: AWS::CodePipeline::Pipeline
    Properties:
      Name: application-migration-pipeline
      RoleArn: !GetAtt CodePipelineRole.Arn
      Stages:
        - Name: Source
          Actions:
            - Name: SourceAction
              ActionTypeId:
                Category: Source
                Owner: AWS
                Provider: S3
                Version: 1
              Configuration:
                S3Bucket: !Ref SourceBucket
                S3ObjectKey: source.zip
        - Name: Build
          Actions:
            - Name: BuildAction
              ActionTypeId:
                Category: Build
                Owner: AWS
                Provider: CodeBuild
                Version: 1
              Configuration:
                ProjectName: !Ref BuildProject
        - Name: Deploy
          Actions:
            - Name: DeployAction
              ActionTypeId:
                Category: Deploy
                Owner: AWS
                Provider: CloudFormation
                Version: 1
              Configuration:
                StackName: !Ref StackName
                TemplatePath: BuildArtifact::template.yaml
```

---

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

### Понимание модели оплаты облака

#### 1. Pay-as-you-go модель

**Принцип:** Оплата только за используемые ресурсы.

**Преимущества:**
- Нет предварительных инвестиций
- Гибкость в масштабировании
- Оплата только за фактическое использование

**Примеры затрат:**
```yaml
# Пример расчета затрат на EC2
ec2_costs:
  instance_type: "t3.micro"
  hourly_rate: "$0.0104"
  monthly_cost: "$7.49"  # 24/7 использование
  annual_cost: "$89.88"

# Пример расчета затрат на S3
s3_costs:
  storage_class: "Standard"
  storage_gb: 100
  monthly_storage: "$2.30"
  requests_per_month: 1000000
  monthly_requests: "$0.40"
  total_monthly: "$2.70"
```

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

**On-Demand Instances**
- Оплата по часам/секундам
- Без долгосрочных обязательств
- Максимальная гибкость

```python
# Калькулятор затрат On-Demand
class OnDemandCostCalculator:
    def __init__(self):
        self.pricing = {
            't3.micro': 0.0104,    # USD per hour
            't3.small': 0.0208,
            't3.medium': 0.0416,
            'm5.large': 0.096,
            'c5.large': 0.085
        }
    
    def calculate_monthly_cost(self, instance_type, hours_per_month=744):
        """Расчет месячной стоимости"""
        hourly_rate = self.pricing.get(instance_type, 0)
        return hourly_rate * hours_per_month
    
    def calculate_annual_cost(self, instance_type, hours_per_month=744):
        """Расчет годовой стоимости"""
        monthly_cost = self.calculate_monthly_cost(instance_type, hours_per_month)
        return monthly_cost * 12

# Использование
calculator = OnDemandCostCalculator()
monthly_cost = calculator.calculate_monthly_cost('t3.medium')
print(f"Monthly cost for t3.medium: ${monthly_cost:.2f}")
```

**Reserved Instances**
- Скидка до 75% при предоплате
- Обязательство на 1-3 года
- Предсказуемые затраты

```python
# Калькулятор Reserved Instances
class ReservedInstanceCalculator:
    def __init__(self):
        self.reserved_pricing = {
            't3.medium': {
                '1_year_no_upfront': 0.025,
                '1_year_partial_upfront': 0.020,
                '1_year_all_upfront': 0.015,
                '3_year_no_upfront': 0.018,
                '3_year_partial_upfront': 0.014,
                '3_year_all_upfront': 0.010
            }
        }
    
    def calculate_savings(self, instance_type, on_demand_rate, reserved_rate):
        """Расчет экономии от Reserved Instances"""
        monthly_on_demand = on_demand_rate * 744
        monthly_reserved = reserved_rate * 744
        monthly_savings = monthly_on_demand - monthly_reserved
        annual_savings = monthly_savings * 12
        savings_percentage = (monthly_savings / monthly_on_demand) * 100
        
        return {
            'monthly_savings': monthly_savings,
            'annual_savings': annual_savings,
            'savings_percentage': savings_percentage
        }

# Использование
ri_calculator = ReservedInstanceCalculator()
savings = ri_calculator.calculate_savings(
    't3.medium', 
    0.0416,  # On-demand rate
    0.015    # 1-year all upfront rate
)
print(f"Annual savings: ${savings['annual_savings']:.2f} ({savings['savings_percentage']:.1f}%)")
```

**Spot Instances**
- До 90% скидка от On-Demand
- Могут быть прерваны в любой момент
- Подходят для fault-tolerant workloads

```python
# Калькулятор Spot Instances
class SpotInstanceCalculator:
    def __init__(self):
        self.spot_pricing = {
            't3.medium': 0.0125,  # Примерная цена
            'm5.large': 0.024,
            'c5.large': 0.021
        }
    
    def calculate_spot_savings(self, instance_type, on_demand_rate):
        """Расчет экономии от Spot Instances"""
        spot_rate = self.spot_pricing.get(instance_type, 0)
        monthly_on_demand = on_demand_rate * 744
        monthly_spot = spot_rate * 744
        monthly_savings = monthly_on_demand - monthly_spot
        savings_percentage = (monthly_savings / monthly_on_demand) * 100
        
        return {
            'monthly_savings': monthly_savings,
            'savings_percentage': savings_percentage,
            'spot_rate': spot_rate
        }

# Использование
spot_calculator = SpotInstanceCalculator()
spot_savings = spot_calculator.calculate_spot_savings('t3.medium', 0.0416)
print(f"Spot savings: {spot_savings['savings_percentage']:.1f}%")
```

#### 3. AWS Cost Calculator

**Онлайн калькулятор AWS:**
- https://calculator.aws/
- Детальный расчет затрат
- Сравнение различных конфигураций
- Экспорт в Excel/PDF

**Программный доступ к ценам:**

```python
# AWS Pricing API
import boto3
import json

class AWSPricingCalculator:
    def __init__(self):
        self.pricing_client = boto3.client('pricing', region_name='us-east-1')
    
    def get_ec2_pricing(self, instance_type, region='us-east-1'):
        """Получение цен на EC2 инстансы"""
        try:
            response = self.pricing_client.get_products(
                ServiceCode='AmazonEC2',
                Filters=[
                    {
                        'Type': 'TERM_MATCH',
                        'Field': 'instanceType',
                        'Value': instance_type
                    },
                    {
                        'Type': 'TERM_MATCH',
                        'Field': 'location',
                        'Value': self.get_region_name(region)
                    }
                ]
            )
            return response
        except Exception as e:
            print(f"Error getting pricing: {e}")
            return None
    
    def get_region_name(self, region_code):
        """Преобразование кода региона в название"""
        region_mapping = {
            'us-east-1': 'US East (N. Virginia)',
            'us-west-2': 'US West (Oregon)',
            'eu-west-1': 'Europe (Ireland)',
            'ap-southeast-1': 'Asia Pacific (Singapore)'
        }
        return region_mapping.get(region_code, region_code)

# Использование
pricing_calc = AWSPricingCalculator()
pricing = pricing_calc.get_ec2_pricing('t3.micro')
```

#### 4. Cost Optimization Strategies

**Right-Sizing**
- Выбор подходящего размера инстансов
- Мониторинг использования ресурсов
- Автоматическое масштабирование

```yaml
# CloudWatch Metrics для Right-Sizing
Resources:
  RightSizingAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmName: LowCPUUtilization
      ComparisonOperator: LessThanThreshold
      EvaluationPeriods: 2
      MetricName: CPUUtilization
      Namespace: AWS/EC2
      Period: 300
      Statistic: Average
      Threshold: 20
      AlarmActions:
        - !Ref SNSNotificationTopic
      Dimensions:
        - Name: InstanceId
          Value: !Ref EC2Instance
```

**Reserved Instances Planning**

```python
# Планировщик Reserved Instances
class ReservedInstancePlanner:
    def __init__(self):
        self.usage_history = {}
    
    def analyze_usage_pattern(self, instance_type, hours_per_month):
        """Анализ паттернов использования"""
        if hours_per_month >= 744:  # 24/7 использование
            return "Full-time usage - consider Reserved Instances"
        elif hours_per_month >= 372:  # 12/7 использование
            return "Part-time usage - consider Scheduled Reserved Instances"
        else:
            return "Variable usage - stick with On-Demand"
    
    def calculate_break_even(self, on_demand_rate, reserved_rate, upfront_cost=0):
        """Расчет точки безубыточности"""
        monthly_savings = (on_demand_rate - reserved_rate) * 744
        if upfront_cost > 0:
            months_to_break_even = upfront_cost / monthly_savings
            return months_to_break_even
        return float('inf')

# Использование
planner = ReservedInstancePlanner()
break_even = planner.calculate_break_even(0.0416, 0.015, 100)
print(f"Break-even point: {break_even:.1f} months")
```

**Storage Optimization**

```yaml
# S3 Lifecycle Configuration
Resources:
  S3Bucket:
    Type: AWS::S3::Bucket
    Properties:
      LifecycleConfiguration:
        Rules:
          - Id: TransitionToIA
            Status: Enabled
            Transitions:
              - StorageClass: STANDARD_IA
                TransitionInDays: 30
          - Id: TransitionToGlacier
            Status: Enabled
            Transitions:
              - StorageClass: GLACIER
                TransitionInDays: 90
          - Id: DeleteOldVersions
            Status: Enabled
            NoncurrentVersionTransitions:
              - StorageClass: GLACIER
                TransitionInDays: 30
            NoncurrentVersionExpirationInDays: 90
```

#### 5. Cost Monitoring and Alerting

**AWS Cost Explorer**
- Визуализация затрат
- Фильтрация по сервисам, регионам, тегам
- Прогнозирование затрат

**Billing Alerts**

```yaml
# CloudWatch Billing Alarm
Resources:
  BillingAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmName: MonthlyBillingAlarm
      AlarmDescription: Alert when monthly costs exceed threshold
      MetricName: EstimatedCharges
      Namespace: AWS/Billing
      Statistic: Maximum
      Period: 86400  # 24 hours
      EvaluationPeriods: 1
      Threshold: 100  # $100
      ComparisonOperator: GreaterThanThreshold
      Dimensions:
        - Name: Currency
          Value: USD
      AlarmActions:
        - !Ref SNSNotificationTopic
```

**Cost Allocation Tags**

```yaml
# Tagging Strategy
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      Tags:
        - Key: Environment
          Value: Production
        - Key: Project
          Value: E-commerce
        - Key: Owner
          Value: DevelopmentTeam
        - Key: CostCenter
          Value: IT-001
        - Key: AutoShutdown
          Value: "false"
```

#### 6. Multi-Cloud Cost Comparison

**Сравнение облачных провайдеров:**

```python
# Сравнительный калькулятор облачных затрат
class MultiCloudCostComparator:
    def __init__(self):
        self.pricing = {
            'aws': {
                't3.micro': 0.0104,
                't3.small': 0.0208,
                't3.medium': 0.0416
            },
            'azure': {
                'B1s': 0.0052,
                'B1ms': 0.0104,
                'B2s': 0.0416
            },
            'gcp': {
                'e2-micro': 0.006,
                'e2-small': 0.012,
                'e2-medium': 0.024
            }
        }
    
    def compare_costs(self, instance_type, hours=744):
        """Сравнение затрат между облачными провайдерами"""
        results = {}
        for provider, instances in self.pricing.items():
            if instance_type in instances:
                monthly_cost = instances[instance_type] * hours
                results[provider] = {
                    'monthly_cost': monthly_cost,
                    'annual_cost': monthly_cost * 12
                }
        return results
    
    def find_cheapest(self, instance_type, hours=744):
        """Поиск самого дешевого варианта"""
        costs = self.compare_costs(instance_type, hours)
        if costs:
            cheapest = min(costs.items(), key=lambda x: x[1]['monthly_cost'])
            return cheapest[0], cheapest[1]

# Использование
comparator = MultiCloudCostComparator()
cheapest_provider, cost = comparator.find_cheapest('t3.micro')
print(f"Cheapest provider: {cheapest_provider}, Monthly cost: ${cost['monthly_cost']:.2f}")
```

### Экономические принципы облачных вычислений

#### 1. CAPEX vs OPEX

**CAPEX (Capital Expenditure) - Капитальные затраты:**
- Покупка оборудования
- Предварительные инвестиции
- Амортизация активов

**OPEX (Operational Expenditure) - Операционные затраты:**
- Оплата по факту использования
- Переменные затраты
- Налоговые преимущества

#### 2. Total Cost of Ownership (TCO)

**Компоненты TCO:**
- Стоимость инфраструктуры
- Стоимость персонала
- Стоимость лицензий
- Стоимость поддержки
- Стоимость безопасности

```python
# TCO Calculator
class TCOCalculator:
    def __init__(self):
        self.components = {
            'infrastructure': 0,
            'personnel': 0,
            'licenses': 0,
            'support': 0,
            'security': 0
        }
    
    def calculate_tco(self, years=3):
        """Расчет TCO за указанный период"""
        total_tco = sum(self.components.values()) * years
        return {
            'total_tco': total_tco,
            'annual_tco': total_tco / years,
            'monthly_tco': total_tco / (years * 12),
            'breakdown': self.components
        }
    
    def compare_on_premise_vs_cloud(self, on_premise_tco, cloud_tco):
        """Сравнение On-Premise vs Cloud"""
        savings = on_premise_tco - cloud_tco
        savings_percentage = (savings / on_premise_tco) * 100
        
        return {
            'savings': savings,
            'savings_percentage': savings_percentage,
            'cloud_advantage': savings > 0
        }

# Использование
tco_calc = TCOCalculator()
tco_calc.components = {
    'infrastructure': 50000,
    'personnel': 120000,
    'licenses': 15000,
    'support': 25000,
    'security': 10000
}

tco_result = tco_calc.calculate_tco(3)
print(f"3-year TCO: ${tco_result['total_tco']:,.2f}")
```

---

## Cost Optimization

### Стратегии оптимизации затрат

#### 1. Right-Sizing
```yaml
# Auto Scaling Configuration
Resources:
  AutoScalingGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    Properties:
      MinSize: 2
      MaxSize: 10
      DesiredCapacity: 3
      LaunchTemplate:
        LaunchTemplateId: !Ref LaunchTemplate
        Version: !GetAtt LaunchTemplate.LatestVersionNumber
      TargetGroupARNs:
        - !Ref TargetGroup
      MetricsCollection:
        - Granularity: 1Minute
          Metrics:
            - GroupDesiredCapacity
            - GroupInServiceInstances
            - GroupTotalInstances

  ScalingPolicy:
    Type: AWS::AutoScaling::ScalingPolicy
    Properties:
      AutoScalingGroupName: !Ref AutoScalingGroup
      PolicyType: TargetTrackingScaling
      TargetTrackingConfiguration:
        TargetValue: 70.0
        PredefinedMetricSpecification:
          PredefinedMetricType: ASGAverageCPUUtilization
```

#### 2. Reserved Instances
```yaml
# Reserved Instance Purchase
Resources:
  ReservedInstance:
    Type: AWS::EC2::ReservedInstances
    Properties:
      InstanceCount: 3
      InstanceType: t3.medium
      OfferingType: All Upfront
      ProductDescription: Linux/UNIX
      ReservedInstancesOfferingId: !Ref ReservedInstancesOffering
```

#### 3. Spot Instances
```yaml
# Spot Instance Configuration
Resources:
  SpotFleet:
    Type: AWS::EC2::SpotFleetRequest
    Properties:
      SpotFleetRequestConfig:
        IamFleetRole: !GetAtt SpotFleetRole.Arn
        TargetCapacity: 5
        LaunchSpecifications:
          - ImageId: ami-0c02fb55956c7d316
            InstanceType: t3.micro
            KeyName: !Ref KeyPair
            SecurityGroups:
              - !Ref SecurityGroup
            UserData:
              Fn::Base64: !Sub |
                #!/bin/bash
                yum update -y
                yum install -y aws-cli
```

### Мониторинг затрат

#### 1. Cost Alerts
```yaml
# Cost Budget Alert
Resources:
  CostBudget:
    Type: AWS::Budgets::Budget
    Properties:
      Budget:
        BudgetName: MonthlyCostBudget
        BudgetLimit:
          Amount: 1000
          Unit: USD
        TimeUnit: MONTHLY
        BudgetType: COST
        CostFilters:
          Service:
            - Amazon Elastic Compute Cloud - Compute
            - Amazon Relational Database Service
        NotificationsWithSubscribers:
          - Notification:
              NotificationType: ACTUAL
              ComparisonOperator: GREATER_THAN
              Threshold: 80
              ThresholdType: PERCENTAGE
            Subscribers:
              - SubscriptionType: EMAIL
                Address: admin@example.com
```

#### 2. Cost Analysis
```python
import boto3
from datetime import datetime, timedelta

def analyze_costs():
    ce_client = boto3.client('ce')
    
    # Get costs for last 30 days
    end_date = datetime.now().strftime('%Y-%m-%d')
    start_date = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d')
    
    response = ce_client.get_cost_and_usage(
        TimePeriod={
            'Start': start_date,
            'End': end_date
        },
        Granularity='DAILY',
        Metrics=['BlendedCost'],
        GroupBy=[
            {
                'Type': 'DIMENSION',
                'Key': 'SERVICE'
            }
        ]
    )
    
    # Analyze costs by service
    for result in response['ResultsByTime']:
        for group in result['Groups']:
            service = group['Keys'][0]
            cost = group['Metrics']['BlendedCost']['Amount']
            print(f"{service}: ${cost}")

if __name__ == "__main__":
    analyze_costs()
```

---

## Практические задания

### Задание 1: Cloud Infrastructure
1. Создайте инфраструктуру в AWS/Azure/GCP
2. Разверните приложение в облаке
3. Настройте мониторинг и алерты

### Задание 2: Migration Planning
1. Создайте план миграции для существующего приложения
2. Оцените затраты и риски
3. Разработайте стратегию тестирования

### Задание 3: Cost Optimization
1. Проанализируйте текущие затраты
2. Предложите стратегии оптимизации
3. Реализуйте автоматическое масштабирование

---

## Дополнительные ресурсы

### Облачные провайдеры
- **AWS**: Amazon Web Services
- **Azure**: Microsoft Azure
- **GCP**: Google Cloud Platform
- **Alibaba Cloud**: Alibaba Cloud
- **IBM Cloud**: IBM Cloud

### Инструменты
- **Infrastructure as Code**: Terraform, CloudFormation, ARM Templates
- **Container Orchestration**: Kubernetes, Docker Swarm
- **Monitoring**: CloudWatch, Azure Monitor, Stackdriver
- **Cost Management**: AWS Cost Explorer, Azure Cost Management

---

## Контрольные вопросы

1. Какие модели обслуживания облачных вычислений вы знаете?
2. В чем разница между IaaS, PaaS и SaaS?
3. Какие основные сервисы предоставляют AWS, Azure и GCP?
4. Что такое Cloud-Native архитектура?
5. Какие стратегии миграции в облако существуют?
6. Как оптимизировать затраты в облаке?
7. Что такое 12-Factor App?
8. Как выбрать подходящую стратегию миграции?