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

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

---

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

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

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

### 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
EOF

# Start application
docker-compose up -d
```

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

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

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

**Технический пример - AWS Elastic Beanstalk:**

```yaml
# .ebextensions/01-packages.config
packages:
  yum:
    git: []
    htop: []

option_settings:
  aws:elasticbeanstalk:container:nodejs:
    NodeCommand: "npm start"
    NodeVersion: 18.19.0
  aws:elasticbeanstalk:application:environment:
    NODE_ENV: production
    PORT: 8080
  aws:elasticbeanstalk:environment:process:default:
    HealthCheckPath: /health
    Port: 8080
    Protocol: HTTP
  aws:autoscaling:launchconfiguration:
    InstanceType: t3.medium
    SecurityGroups: default
  aws:elasticbeanstalk:environment:
    LoadBalancerType: application
    ServiceRole: aws-elasticbeanstalk-service-role
  aws:elbv2:loadbalancer:
    IdleTimeout: 60
  aws:autoscaling:asg:
    MinSize: 1
    MaxSize: 10
  aws:autoscaling:trigger:
    MeasureName: CPUUtilization
    Unit: Percent
    LowerThreshold: 20
    UpperThreshold: 80
    ScaleUpIncrement: 1
    ScaleDownIncrement: -1
```

```json
// package.json
{
  "name": "my-app",
  "version": "1.0.0",
  "description": "My Node.js application",
  "main": "app.js",
  "scripts": {
    "start": "node app.js",
    "dev": "nodemon app.js",
    "test": "jest"
  },
  "dependencies": {
    "express": "^4.18.2",
    "cors": "^2.8.5",
    "helmet": "^7.1.0",
    "morgan": "^1.10.0",
    "compression": "^1.7.4",
    "dotenv": "^16.3.1"
  },
  "devDependencies": {
    "nodemon": "^3.0.2",
    "jest": "^29.7.0"
  },
  "engines": {
    "node": ">=18.0.0",
    "npm": ">=8.0.0"
  }
}
```

```javascript
// app.js
const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');
const compression = require('compression');
require('dotenv').config();

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

// Middleware
app.use(helmet());
app.use(cors());
app.use(compression());
app.use(morgan('combined'));
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// 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'
  });
});

// API routes
app.get('/api/status', (req, res) => {
  res.json({
    message: 'API is running',
    version: '1.0.0',
    environment: process.env.NODE_ENV || 'development'
  });
});

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

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

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

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

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

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

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

#### 1. Public Cloud
- Ресурсы принадлежат провайдеру
- Общие с другими клиентами
- Примеры: AWS, Azure, GCP

#### 2. Private Cloud
- Ресурсы принадлежат организации
- Изолированная инфраструктура
- Примеры: VMware vCloud, OpenStack

#### 3. Hybrid Cloud
- Комбинация public и private cloud
- Гибкость в выборе размещения данных
- Примеры: AWS Outposts, Azure Arc

#### 4. Multi-Cloud
- Использование нескольких провайдеров
- Избежание vendor lock-in
- Примеры: AWS + Azure + GCP

### Ключевые характеристики облачных вычислений

#### 1. On-Demand Self-Service
- Автоматическое предоставление ресурсов
- Самообслуживание через портал или API

#### 2. Broad Network Access
- Доступ через стандартные сетевые протоколы
- Поддержка различных устройств

#### 3. Resource Pooling
- Объединение ресурсов для множества клиентов
- Динамическое перераспределение

#### 4. Rapid Elasticity
- Быстрое масштабирование ресурсов
- Автоматическое управление нагрузкой

#### 5. Measured Service
- Мониторинг и измерение использования
- Прозрачность затрат

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

#### 1. Экономические преимущества
- **CAPEX vs OPEX**: Переход от капитальных к операционным расходам
- **Экономия масштаба**: Снижение стоимости за счет больших объемов
- **Pay-as-you-go**: Оплата только за используемые ресурсы

#### 2. Технические преимущества
- **Масштабируемость**: Горизонтальное и вертикальное масштабирование
- **Надежность**: Высокая доступность и отказоустойчивость
- **Безопасность**: Профессиональная защита данных

#### 3. Операционные преимущества
- **Быстрое развертывание**: Ускорение time-to-market
- **Автоматизация**: Уменьшение ручной работы
- **Глобальное присутствие**: Развертывание в разных регионах

### Риски и вызовы

#### 1. Безопасность
- **Data Breaches**: Утечки данных
- **Compliance**: Соответствие регулятивным требованиям
- **Access Control**: Управление доступом

#### 2. Vendor Lock-in
- **Dependency**: Зависимость от провайдера
- **Migration**: Сложность миграции
- **Standards**: Отсутствие стандартов

#### 3. Управление затратами
- **Cost Visibility**: Видимость затрат
- **Resource Optimization**: Оптимизация ресурсов
- **Budget Control**: Контроль бюджета

### Стратегии миграции в облако

#### 1. Lift and Shift
- Перенос приложений без изменений
- Быстрая миграция
- Минимальные риски

#### 2. Replatforming
- Небольшие изменения для облака
- Улучшение производительности
- Баланс скорости и оптимизации

#### 3. Refactoring
- Переписывание для облака
- Максимальная оптимизация
- Долгосрочные преимущества

#### 4. Rebuilding
- Полная перестройка
- Cloud-native архитектура
- Максимальная эффективность

### Инструменты и технологии

#### 1. Infrastructure as Code (IaC)
- **Terraform**: Multi-cloud IaC
- **CloudFormation**: AWS-specific
- **ARM Templates**: Azure-specific

#### 2. Containerization
- **Docker**: Контейнеризация приложений
- **Kubernetes**: Оркестрация контейнеров
- **Helm**: Управление пакетами

#### 3. Monitoring and Observability
- **CloudWatch**: AWS мониторинг
- **Azure Monitor**: Azure мониторинг
- **Stackdriver**: GCP мониторинг

#### 4. Security
- **IAM**: Управление доступом
- **VPC**: Виртуальные сети
- **Encryption**: Шифрование данных