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

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

---

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

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

#### 1. Избежание Vendor Lock-in
- Независимость от одного провайдера
- Гибкость в выборе лучших сервисов
- Снижение рисков

#### 2. Оптимизация затрат
- Сравнение цен между провайдерами
- Использование spot instances
- Выбор наиболее экономичных решений

#### 3. Повышение надежности
- Распределение рисков
- Географическое распределение
- Disaster recovery

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

#### 1. Cloud-Agnostic Design
- Абстракция от конкретных облачных провайдеров
- Использование стандартных технологий
- Портабельность приложений

```yaml
# Kubernetes deployment для мультиоблака
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
  labels:
    app: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: user-service:v1.0.0
        ports:
        - containerPort: 8080
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: user-service-secrets
              key: database-url
        - name: CACHE_URL
          valueFrom:
            configMapKeyRef:
              name: user-service-config
              key: cache-url
        - name: MESSAGE_QUEUE_URL
          valueFrom:
            configMapKeyRef:
              name: user-service-config
              key: message-queue-url
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
```

#### 2. Service Mesh для мультиоблака
- Управление трафиком между облаками
- Безопасность и мониторинг
- Load balancing и failover

```yaml
# Istio Service Mesh configuration
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: user-service
spec:
  host: user-service
  trafficPolicy:
    loadBalancer:
      simple: ROUND_ROBIN
    connectionPool:
      tcp:
        maxConnections: 10
      http:
        http1MaxPendingRequests: 10
        maxRequestsPerConnection: 2
    circuitBreaker:
      consecutiveErrors: 3
      interval: 30s
      baseEjectionTime: 30s
      maxEjectionPercent: 50
    outlierDetection:
      consecutiveErrors: 3
      interval: 30s
      baseEjectionTime: 30s
      maxEjectionPercent: 50
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: user-service
spec:
  hosts:
  - user-service
  http:
  - match:
    - headers:
        cloud:
          exact: aws
    route:
    - destination:
        host: user-service-aws
        subset: v1
  - match:
    - headers:
        cloud:
          exact: azure
    route:
    - destination:
        host: user-service-azure
        subset: v1
  - route:
    - destination:
        host: user-service
        subset: v1
      weight: 100
```

### Инструменты для мультиоблака

#### 1. Terraform для мультиоблака
- Infrastructure as Code для разных провайдеров
- Управление ресурсами из одного места
- Версионирование инфраструктуры

```hcl
# terraform/main.tf
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
    azure = {
      source  = "hashicorp/azurerm"
      version = "~> 3.0"
    }
    gcp = {
      source  = "hashicorp/google"
      version = "~> 4.0"
    }
  }
}

# AWS Resources
provider "aws" {
  region = var.aws_region
}

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
  }
}

resource "aws_subnet" "public" {
  count = length(var.aws_availability_zones)

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

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

# Azure Resources
provider "azurerm" {
  features {}
}

resource "azurerm_resource_group" "main" {
  name     = "${var.project_name}-rg"
  location = var.azure_location

  tags = {
    Environment = var.environment
    Project     = var.project_name
  }
}

resource "azurerm_virtual_network" "main" {
  name                = "${var.project_name}-vnet"
  address_space       = ["10.1.0.0/16"]
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name

  tags = {
    Environment = var.environment
    Project     = var.project_name
  }
}

resource "azurerm_subnet" "public" {
  count = length(var.azure_availability_zones)

  name                 = "public-subnet-${count.index + 1}"
  resource_group_name  = azurerm_resource_group.main.name
  virtual_network_name = azurerm_virtual_network.main.name
  address_prefixes     = ["10.1.${count.index + 1}.0/24"]
}

# GCP Resources
provider "google" {
  project = var.gcp_project_id
  region  = var.gcp_region
}

resource "google_compute_network" "main" {
  name                    = "${var.project_name}-vpc"
  auto_create_subnetworks = false
  mtu                     = 1460
}

resource "google_compute_subnetwork" "public" {
  count = length(var.gcp_zones)

  name          = "public-subnet-${count.index + 1}"
  ip_cidr_range = "10.2.${count.index + 1}.0/24"
  region        = var.gcp_region
  network       = google_compute_network.main.id
}
```

#### 2. Kubernetes для мультиоблака
- Единая платформа для всех облаков
- Портабельность приложений
- Управление ресурсами

```yaml
# Kubernetes Cluster API для мультиоблака
apiVersion: cluster.x-k8s.io/v1beta1
kind: Cluster
metadata:
  name: multi-cloud-cluster
  namespace: default
spec:
  clusterNetwork:
    pods:
      cidrBlocks: ["192.168.0.0/16"]
    services:
      cidrBlocks: ["10.96.0.0/12"]
  controlPlaneRef:
    apiVersion: controlplane.cluster.x-k8s.io/v1beta1
    kind: KubeadmControlPlane
    name: multi-cloud-cluster-control-plane
  infrastructureRef:
    apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
    kind: AWSCluster
    name: multi-cloud-cluster
---
apiVersion: cluster.x-k8s.io/v1beta1
kind: MachineDeployment
metadata:
  name: multi-cloud-cluster-md-0
  namespace: default
spec:
  clusterName: multi-cloud-cluster
  replicas: 3
  selector:
    matchLabels:
      cluster.x-k8s.io/cluster-name: multi-cloud-cluster
      cluster.x-k8s.io/deployment-name: multi-cloud-cluster-md-0
  template:
    spec:
      clusterName: multi-cloud-cluster
      bootstrap:
        configRef:
          apiVersion: bootstrap.cluster.x-k8s.io/v1beta1
          kind: KubeadmConfigTemplate
          name: multi-cloud-cluster-md-0
      infrastructureRef:
        apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
        kind: AWSMachineTemplate
        name: multi-cloud-cluster-md-0
```

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

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

#### 1. Постепенная миграция
- Минимальные риски
- Тестирование в облаке
- Поэтапный переход

#### 2. Соответствие требованиям
- Соблюдение регулятивных требований
- Контроль над чувствительными данными
- Гибридные рабочие нагрузки

#### 3. Оптимизация затрат
- Использование существующих инвестиций
- Выбор оптимального размещения для каждой нагрузки
- Гибкость в управлении ресурсами

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

#### 1. Hybrid Cloud Connectivity
- VPN соединения между on-premises и облаком
- Dedicated connections (AWS Direct Connect, Azure ExpressRoute)
- Secure tunnels и encryption

```yaml
# AWS Direct Connect configuration
Resources:
  DirectConnectGateway:
    Type: AWS::DirectConnect::Gateway
    Properties:
      Name: my-dx-gateway
      AmazonSideAsn: 64512

  VirtualPrivateGateway:
    Type: AWS::EC2::VPNGateway
    Properties:
      Type: ipsec.1
      Tags:
        - Key: Name
          Value: my-vpg

  VPNConnection:
    Type: AWS::EC2::VPNConnection
    Properties:
      Type: ipsec.1
      CustomerGatewayId: !Ref CustomerGateway
      VpnGatewayId: !Ref VirtualPrivateGateway
      StaticRoutesOnly: false
      Tags:
        - Key: Name
          Value: my-vpn-connection

  CustomerGateway:
    Type: AWS::EC2::CustomerGateway
    Properties:
      BgpAsn: 65000
      IpAddress: 203.0.113.12
      Type: ipsec.1
      Tags:
        - Key: Name
          Value: my-customer-gateway
```

#### 2. Data Synchronization
- Синхронизация данных между on-premises и облаком
- Real-time и batch processing
- Conflict resolution

```javascript
// Data synchronization service
const express = require('express');
const { Kafka } = require('kafkajs');
const { Pool } = require('pg');

const app = express();
app.use(express.json());

// Database connections
const onPremisesDB = new Pool({
  host: process.env.ON_PREMISES_DB_HOST,
  port: process.env.ON_PREMISES_DB_PORT,
  database: process.env.ON_PREMISES_DB_NAME,
  user: process.env.ON_PREMISES_DB_USER,
  password: process.env.ON_PREMISES_DB_PASSWORD
});

const cloudDB = new Pool({
  host: process.env.CLOUD_DB_HOST,
  port: process.env.CLOUD_DB_PORT,
  database: process.env.CLOUD_DB_NAME,
  user: process.env.CLOUD_DB_USER,
  password: process.env.CLOUD_DB_PASSWORD
});

// Kafka configuration
const kafka = new Kafka({
  clientId: 'data-sync-service',
  brokers: [process.env.KAFKA_BROKER]
});

const producer = kafka.producer();
const consumer = kafka.consumer({ groupId: 'data-sync-group' });

// Data synchronization functions
async function syncDataToCloud(tableName, data) {
  try {
    // Insert or update data in cloud database
    const query = `
      INSERT INTO ${tableName} (id, data, updated_at)
      VALUES ($1, $2, $3)
      ON CONFLICT (id) DO UPDATE SET
        data = EXCLUDED.data,
        updated_at = EXCLUDED.updated_at
    `;
    
    await cloudDB.query(query, [data.id, JSON.stringify(data), new Date()]);
    
    console.log(`Data synced to cloud: ${tableName}/${data.id}`);
  } catch (error) {
    console.error('Error syncing data to cloud:', error);
    throw error;
  }
}

async function syncDataToOnPremises(tableName, data) {
  try {
    // Insert or update data in on-premises database
    const query = `
      INSERT INTO ${tableName} (id, data, updated_at)
      VALUES ($1, $2, $3)
      ON CONFLICT (id) DO UPDATE SET
        data = EXCLUDED.data,
        updated_at = EXCLUDED.updated_at
    `;
    
    await onPremisesDB.query(query, [data.id, JSON.stringify(data), new Date()]);
    
    console.log(`Data synced to on-premises: ${tableName}/${data.id}`);
  } catch (error) {
    console.error('Error syncing data to on-premises:', error);
    throw error;
  }
}

// Kafka consumer for data changes
async function startDataSync() {
  await consumer.connect();
  await consumer.subscribe({ topic: 'data-changes' });
  
  await consumer.run({
    eachMessage: async ({ topic, partition, message }) => {
      try {
        const data = JSON.parse(message.value.toString());
        
        if (data.source === 'on-premises') {
          await syncDataToCloud(data.table, data.payload);
        } else if (data.source === 'cloud') {
          await syncDataToOnPremises(data.table, data.payload);
        }
      } catch (error) {
        console.error('Error processing message:', error);
      }
    }
  });
}

// API endpoints for manual sync
app.post('/sync/on-premises-to-cloud', async (req, res) => {
  try {
    const { table, data } = req.body;
    await syncDataToCloud(table, data);
    res.json({ status: 'success' });
  } catch (error) {
    res.status(500).json({ error: 'Sync failed' });
  }
});

app.post('/sync/cloud-to-on-premises', async (req, res) => {
  try {
    const { table, data } = req.body;
    await syncDataToOnPremises(table, data);
    res.json({ status: 'success' });
  } catch (error) {
    res.status(500).json({ error: 'Sync failed' });
  }
});

// Start the service
async function start() {
  await producer.connect();
  await startDataSync();
  
  app.listen(3000, () => {
    console.log('Data sync service listening on port 3000');
  });
}

start().catch(console.error);
```

#### 3. Workload Placement
- Интеллектуальное размещение рабочих нагрузок
- Автоматическое масштабирование
- Cost optimization

```yaml
# Kubernetes scheduler для гибридного облака
apiVersion: v1
kind: ConfigMap
metadata:
  name: scheduler-config
data:
  policy.cfg: |
    {
      "kind": "Policy",
      "apiVersion": "v1",
      "predicates": [
        {
          "name": "NodeAffinity"
        },
        {
          "name": "PodToleratesNodeTaints"
        },
        {
          "name": "CheckNodeMemoryPressure"
        },
        {
          "name": "CheckNodeDiskPressure"
        },
        {
          "name": "CheckNodePIDPressure"
        },
        {
          "name": "MatchNodeSelector"
        },
        {
          "name": "CheckVolumeBinding"
        }
      ],
      "priorities": [
        {
          "name": "NodeAffinityPriority",
          "weight": 10
        },
        {
          "name": "BalancedResourceAllocation",
          "weight": 1
        },
        {
          "name": "LeastRequestedPriority",
          "weight": 1
        },
        {
          "name": "MostRequestedPriority",
          "weight": 1
        },
        {
          "name": "NodePreferAvoidPodsPriority",
          "weight": 10000
        },
        {
          "name": "NodeLabelPriority",
          "weight": 10,
          "argument": {
            "presentLabels": ["cloud-provider"],
            "absentLabels": ["on-premises"]
          }
        }
      ]
    }
---
apiVersion: v1
kind: Pod
metadata:
  name: workload-placement-example
spec:
  containers:
  - name: app
    image: my-app:latest
    resources:
      requests:
        memory: "256Mi"
        cpu: "250m"
      limits:
        memory: "512Mi"
        cpu: "500m"
  nodeSelector:
    cloud-provider: "aws"
    instance-type: "compute-optimized"
  tolerations:
  - key: "cloud-provider"
    operator: "Equal"
    value: "aws"
    effect: "NoSchedule"
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: cloud-provider
            operator: In
            values: ["aws", "azure"]
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        preference:
          matchExpressions:
          - key: instance-type
            operator: In
            values: ["compute-optimized"]
```

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

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

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

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

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

## Best Practices

### 1. Security
- Единая политика безопасности
- Централизованное управление доступом
- Мониторинг и аудит

### 2. Monitoring
- Единая система мониторинга
- Централизованное логирование
- Alerting и notification

### 3. Cost Management
- Мониторинг затрат
- Оптимизация ресурсов
- Автоматическое масштабирование

### 4. Disaster Recovery
- План восстановления
- Тестирование процедур
- Документирование процессов