┌──────────────────────────────────────────────────────────┐
│                    Физический сервер                      │
│                     Proxmox VE                            │
├──────────────────────────────────────────────────────────┤
│                                                            │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────────┐  │
│  │  GitLab VM   │  │ Database VM  │  │ Kubernetes VM │  │
│  ├──────────────┤  ├──────────────┤  ├───────────────┤  │
│  │ • GitLab CE  │  │ • PostgreSQL │  │ • Backend     │  │
│  │ • Registry   │  │ • Redis      │  │ • Celery      │  │
│  │ • Runner     │  │ • Minio      │  │ • Zitadel     │  │
│  │              │  │              │  │ • RabbitMQ    │  │
│  └──────────────┘  └──────────────┘  └───────────────┘  │
│                                                            │
│            Управляется через Terraform                     │
└──────────────────────────────────────────────────────────┘

Всё разворачивается на собственном сервере:

┌─────────────────────────────────────┐
│     Физический сервер (Proxmox)     │
├─────────────────────────────────────┤
│ • GitLab VM (self-hosted)           │
│ • PostgreSQL VM (self-hosted)       │
│ • Kubernetes VM (self-hosted)       │
└─────────────────────────────────────┘

Terraform Provider: telmate/proxmox

┌──────────────────────────────────────────────────────┐
│  On-premise (Proxmox или VPS)                        │
├──────────────────────────────────────────────────────┤
│  • Kubernetes VM (self-hosted)                       │
│    └─ Backend Platform, Celery Workers, Zitadel      │
└──────────────────────────────────────────────────────┘
                      ↓ ↑
┌──────────────────────────────────────────────────────┐
│  Облачные Managed сервисы                            │
├──────────────────────────────────────────────────────┤
│  • GitLab.com (SaaS) — бесплатный план               │
│  • Managed PostgreSQL (AWS RDS / Yandex Cloud)       │
│  • Managed Redis (AWS ElastiCache / Yandex Cache)    │
│  • S3 Storage (AWS S3 / Yandex Object Storage)       │
└──────────────────────────────────────────────────────┘

Terraform Providers:
  - telmate/proxmox (для K8s VM)
  - hashicorp/aws (для RDS, ElastiCache, S3)
  - yandex-cloud/yandex (для Managed PostgreSQL)

On-premise:
  ✅ Kubernetes (Backend, Celery, Zitadel, RabbitMQ)

Облако:
  ✅ GitLab.com Free Tier (бесплатно, 5 GB storage)
  ✅ Managed PostgreSQL (AWS RDS / Yandex Cloud)
  ✅ Managed Redis
  ✅ S3 Storage (для Minio замена)

Экономия ресурсов: -8 CPU, -16 GB RAM
Стоимость: ~$30-50/мес

On-premise:
  ✅ Kubernetes
  ✅ GitLab VM (self-hosted)
  ✅ Redis, Minio (в K8s)

Облако:
  ✅ Managed PostgreSQL только

Экономия ресурсов: -4 CPU, -8 GB RAM (освобождается database-vm)
Стоимость: ~$20-40/мес

On-premise:
  ✅ Kubernetes VM только (Backend Platform + Celery Workers)

Облако:
  ✅ GitLab.com или Managed GitLab
  ✅ Managed PostgreSQL
  ✅ Managed Redis
  ✅ S3 Storage

Экономия ресурсов: -12 CPU, -24 GB RAM
Стоимость: ~$60-100/мес

┌──────────────────────────────────────────────────────┐
│  Облачный провайдер (AWS / GCP / Azure / Yandex)     │
├──────────────────────────────────────────────────────┤
│  • Managed Kubernetes (EKS / GKE / AKS / YC K8s)     │
│    └─ Backend Platform, Celery Workers, Zitadel      │
│  • Managed PostgreSQL (RDS / Cloud SQL / Managed DB) │
│  • Managed Redis (ElastiCache / Memorystore / Cache) │
│  • S3 Storage (S3 / GCS / Blob / Object Storage)     │
│  • GitLab.com (SaaS) или Managed GitLab             │
└──────────────────────────────────────────────────────┘

Terraform Providers:
  - hashicorp/aws (для AWS)
  - hashicorp/google (для GCP)
  - hashicorp/azurerm (для Azure)
  - yandex-cloud/yandex (для Yandex Cloud)

# AWS RDS PostgreSQL
resource "aws_db_instance" "ksailab_postgres" {
  identifier             = "ksailab-postgres"
  engine                 = "postgres"
  engine_version         = "15.4"
  instance_class         = "db.t3.medium"
  allocated_storage      = 100
  storage_type           = "gp3"

  db_name  = "ksailab"
  username = "admin"
  password = var.db_password

  multi_az               = true  # High Availability
  backup_retention_period = 7
  backup_window          = "03:00-04:00"

  vpc_security_group_ids = [aws_security_group.db.id]

  tags = {
    Environment = "production"
    Project     = "KSAILab"
  }
}

# Yandex Cloud Managed PostgreSQL
resource "yandex_mdb_postgresql_cluster" "ksailab_postgres" {
  name        = "ksailab-postgres"
  environment = "PRODUCTION"
  network_id  = yandex_vpc_network.ksailab.id

  config {
    version = "15"
    resources {
      resource_preset_id = "s2.micro"  # 2 vCPU, 8 GB RAM
      disk_type_id       = "network-ssd"
      disk_size          = 100
    }
  }

  host {
    zone      = "ru-central1-a"
    subnet_id = yandex_vpc_subnet.ksailab_a.id
  }

  host {
    zone      = "ru-central1-b"  # HA replica
    subnet_id = yandex_vpc_subnet.ksailab_b.id
  }
}

# AWS EKS
resource "aws_eks_cluster" "ksailab" {
  name     = "ksailab-cluster"
  role_arn = aws_iam_role.eks_cluster.arn
  version  = "1.28"

  vpc_config {
    subnet_ids = [
      aws_subnet.private_a.id,
      aws_subnet.private_b.id,
    ]
  }
}

resource "aws_eks_node_group" "ksailab_nodes" {
  cluster_name    = aws_eks_cluster.ksailab.name
  node_group_name = "ksailab-nodes"
  node_role_arn   = aws_iam_role.eks_nodes.arn
  subnet_ids      = [aws_subnet.private_a.id, aws_subnet.private_b.id]

  scaling_config {
    desired_size = 2
    max_size     = 5
    min_size     = 1
  }

  instance_types = ["t3.medium"]  # 2 vCPU, 4 GB RAM
}

# Yandex Managed Kubernetes
resource "yandex_kubernetes_cluster" "ksailab" {
  name        = "ksailab-cluster"
  network_id  = yandex_vpc_network.ksailab.id

  master {
    version = "1.28"
    zonal {
      zone      = "ru-central1-a"
      subnet_id = yandex_vpc_subnet.ksailab_a.id
    }

    public_ip = true
  }

  service_account_id      = yandex_iam_service_account.k8s_sa.id
  node_service_account_id = yandex_iam_service_account.k8s_nodes_sa.id
}

resource "yandex_kubernetes_node_group" "ksailab_nodes" {
  cluster_id = yandex_kubernetes_cluster.ksailab.id
  name       = "ksailab-nodes"

  instance_template {
    platform_id = "standard-v2"
    resources {
      cores  = 2
      memory = 4
    }

    boot_disk {
      type = "network-ssd"
      size = 64
    }
  }

  scale_policy {
    auto_scale {
      min     = 1
      max     = 5
      initial = 2
    }
  }
}

# providers.tf
terraform {
  required_version = ">= 1.5.0"

  required_providers {
    # On-premise infrastructure
    proxmox = {
      source  = "telmate/proxmox"
      version = "~> 2.9"
    }

    # Managed database в AWS
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

# Proxmox для K8s VM
provider "proxmox" {
  pm_api_url = var.proxmox_api_url
  pm_user    = var.proxmox_user
  pm_password = var.proxmox_password
}

# AWS для Managed PostgreSQL
provider "aws" {
  region = "eu-west-1"
  access_key = var.aws_access_key
  secret_key = var.aws_secret_key
}

# k8s-vm.tf (в Proxmox)
resource "proxmox_vm_qemu" "k8s_vm" {
  name   = "k8s-vm"
  cores  = 8
  memory = 16384
  # ... остальная конфигурация
}

# database.tf (в AWS)
resource "aws_db_instance" "ksailab_postgres" {
  identifier        = "ksailab-postgres"
  engine            = "postgres"
  instance_class    = "db.t3.medium"
  allocated_storage = 100
  # ... остальная конфигурация
}

✅ Сценарий A: On-premise (Proxmox)

Почему:
• Нулевая стоимость (кроме электричества/аренды сервера)
• Полный контроль для обучения студентов
• Terraform + Proxmox — хороший пример IaC
• Достаточно для 50 студентов

Альтернатива при ограниченных ресурсах:
⚠️ Сценарий B (Вариант B2): K8s + GitLab на Proxmox, только PostgreSQL в облаке
• Yandex Managed PostgreSQL (~$25/мес)
• Освобождает 4 CPU и 8 GB RAM на сервере

✅ Сценарий B (Вариант B1): Гибридный подход

On-premise (Proxmox или Hetzner Dedicated):
• Multi-node Kubernetes (3 masters + 2 workers)

Облако (Yandex Cloud — дешевле для РФ):
• Managed PostgreSQL (~$25/мес)
• Managed Redis (~$10/мес)
• Object Storage (~$2/мес)
• GitLab.com Free Tier ($0)

Итого: ~$40/мес + стоимость сервера

✅ Сценарий C: Полностью облачный (AWS или Yandex Cloud)

• Managed Kubernetes (EKS / Yandex K8s)
• Managed PostgreSQL с Multi-AZ
• Managed Redis
• S3 Storage
• CloudWatch / Yandex Monitoring
• Автоматические бэкапы и DR

Итого: ~$150-300/мес в зависимости от нагрузки
Преимущество: 99.9% uptime, автоматическое масштабирование, минимум управления

┌─────────────────────────────────────────────────────────────────┐
│                    Физический сервер                             │
│                  Proxmox VE (Hypervisor)                         │
│  • CPU: 12-24 cores                                              │
│  • RAM: 16-32 GB                                                 │
│  • Disk: 500 GB - 1 TB SSD                                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  Виртуальная сеть: vmbr0 (Bridge)                               │
│  ├─ 192.168.100.0/24 (единая подсеть для MVP)                   │
│  │                                                                │
│  ├─ 192.168.100.10 → gitlab-vm                                   │
│  ├─ 192.168.100.20 → database-vm                                 │
│  └─ 192.168.100.30 → k8s-vm                                      │
│                                                                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  ┌──────────────────────┐                                        │
│  │   gitlab-vm          │                                        │
│  ├──────────────────────┤                                        │
│  │ • OS: Ubuntu 22.04   │                                        │
│  │ • CPU: 4 cores       │                                        │
│  │ • RAM: 8 GB          │                                        │
│  │ • Disk: 100 GB       │                                        │
│  │ • IP: 192.168.100.10 │                                        │
│  │                      │                                        │
│  │ Установлено:         │                                        │
│  │ • GitLab CE          │                                        │
│  │ • GitLab Runner      │                                        │
│  │ • Container Registry │                                        │
│  └──────────────────────┘                                        │
│                                                                   │
│  ┌──────────────────────┐                                        │
│  │   database-vm        │                                        │
│  ├──────────────────────┤                                        │
│  │ • OS: Ubuntu 22.04   │                                        │
│  │ • CPU: 4 cores       │                                        │
│  │ • RAM: 8 GB          │                                        │
│  │ • Disk: 200 GB       │                                        │
│  │ • IP: 192.168.100.20 │                                        │
│  │                      │                                        │
│  │ Установлено:         │                                        │
│  │ • PostgreSQL 15      │                                        │
│  │   ├─ DB: ksailab    │                                        │
│  │   ├─ DB: zitadel     │                                        │
│  │   └─ DB: gitlab      │                                        │
│  │ • Redis 7            │                                        │
│  │ • Minio              │                                        │
│  └──────────────────────┘                                        │
│                                                                   │
│  ┌──────────────────────┐                                        │
│  │   k8s-vm             │                                        │
│  ├──────────────────────┤                                        │
│  │ • OS: Ubuntu 22.04   │                                        │
│  │ • CPU: 4-16 cores    │                                        │
│  │ • RAM: 8-16 GB       │                                        │
│  │ • Disk: 200 GB       │                                        │
│  │ • IP: 192.168.100.30 │                                        │
│  │                      │                                        │
│  │ Установлено:         │                                        │
│  │ • Kubernetes 1.28+   │                                        │
│  │ • containerd         │                                        │
│  │ • CNI: Calico        │                                        │
│  │ • Ingress: nginx     │                                        │
│  │                      │                                        │
│  │ Namespaces:          │                                        │
│  │ • platform           │                                        │
│  │ • infrastructure     │                                        │
│  │ • auth               │                                        │
│  │ • messaging          │                                        │
│  │ • labs               │                                        │
│  │ • ingress-nginx      │                                        │
│  └──────────────────────┘                                        │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

Все VM находятся в одной подсети:
192.168.100.0/24

Преимущества:
✅ Простая настройка
✅ Все компоненты видят друг друга
✅ Не требуется настройка routing/firewall

Недостатки:
⚠️ Нет изоляции между компонентами
⚠️ Все сервисы в одном broadcast domain

Безопасность обеспечивается:
• Firewall на уровне каждой VM (ufw)
• Network Policies в Kubernetes
• Отсутствие публичного доступа к внутренним сервисам

Для production рекомендуется разделить на VLAN'ы:

VLAN 10: Management Network (192.168.10.0/24)
├─ Proxmox Web UI
└─ SSH доступ к VM

VLAN 100: Infrastructure (192.168.100.0/24)
├─ 192.168.100.10 → gitlab-vm
├─ 192.168.100.20 → database-vm
└─ 192.168.100.30 → k8s-vm (control plane)

VLAN 200: Kubernetes Workloads (192.168.200.0/24)
└─ Pod network (calico)

VLAN 300: Labs Network (192.168.300.0/24)
└─ Изолированная сеть для лабораторных работ студентов

DMZ (10.0.0.0/24)
└─ Публичный доступ через Ingress

-- Единый PostgreSQL сервер с тремя базами данных

CREATE DATABASE ksailab;   -- Основная БД платформы
CREATE DATABASE zitadel;    -- БД для Zitadel (авторизация)
CREATE DATABASE gitlab;     -- БД для GitLab CE

-- Отдельные пользователи для каждой БД
CREATE USER ksailab_user WITH PASSWORD 'strong_password';
CREATE USER zitadel_user WITH PASSWORD 'strong_password';
CREATE USER gitlab_user WITH PASSWORD 'strong_password';

-- Выдача прав
GRANT ALL PRIVILEGES ON DATABASE ksailab TO ksailab_user;
GRANT ALL PRIVILEGES ON DATABASE zitadel TO zitadel_user;
GRANT ALL PRIVILEGES ON DATABASE gitlab TO gitlab_user;

Для высоконагруженных систем:

• PostgreSQL для ksailab (отдельная VM)
• PostgreSQL для zitadel (отдельная VM)
• PostgreSQL для gitlab (отдельная VM)

Или использование управляемых БД:
• AWS RDS PostgreSQL
• Google Cloud SQL
• Managed PostgreSQL от Hetzner

k8s-vm (192.168.100.30)
└─ Один узел выполняет роли:
   • Control Plane (kube-apiserver, etcd, scheduler)
   • Worker Node (kubelet, container runtime)

Установка: kubeadm + containerd

# Разрешаем запуск pod'ов на control plane node
kubectl taint nodes --all node-role.kubernetes.io/control-plane-

Для production:

k8s-master-1 (192.168.100.31) → Control Plane
k8s-master-2 (192.168.100.32) → Control Plane
k8s-master-3 (192.168.100.33) → Control Plane (etcd требует 3+ узла)

k8s-worker-1 (192.168.100.41) → Worker Node
k8s-worker-2 (192.168.100.42) → Worker Node
k8s-worker-3 (192.168.100.43) → Worker Node

Установка: kubeadm + HA setup + внешний load balancer

terraform/
├── main.tf               # Главный файл конфигурации
├── variables.tf          # Переменные
├── outputs.tf            # Выходные данные
├── providers.tf          # Провайдеры (Proxmox)
├── gitlab-vm.tf          # Конфигурация GitLab VM
├── database-vm.tf        # Конфигурация Database VM
├── k8s-vm.tf             # Конфигурация Kubernetes VM
├── network.tf            # Настройки сети
└── terraform.tfvars      # Значения переменных (НЕ коммитить!)

terraform {
  required_version = ">= 1.5.0"

  required_providers {
    proxmox = {
      source  = "telmate/proxmox"
      version = "~> 2.9"
    }
  }
}

provider "proxmox" {
  pm_api_url      = var.proxmox_api_url
  pm_user         = var.proxmox_user
  pm_password     = var.proxmox_password
  pm_tls_insecure = true  # Для self-signed сертификатов
}

variable "proxmox_api_url" {
  description = "URL Proxmox API"
  type        = string
  default     = "https://192.168.1.100:8006/api2/json"
}

variable "proxmox_user" {
  description = "Proxmox пользователь"
  type        = string
  default     = "root@pam"
}

variable "proxmox_password" {
  description = "Пароль Proxmox"
  type        = string
  sensitive   = true
}

variable "ssh_public_key" {
  description = "SSH публичный ключ для доступа к VM"
  type        = string
}

variable "vm_template" {
  description = "ID template Ubuntu 22.04 в Proxmox"
  type        = string
  default     = "9000"
}

resource "proxmox_vm_qemu" "gitlab_vm" {
  name        = "gitlab-vm"
  desc        = "GitLab CE + Container Registry + Runner"
  target_node = var.proxmox_node

  # Клонирование из template
  clone = var.vm_template

  # Ресурсы
  cores   = 4
  sockets = 1
  memory  = 8192  # 8 GB

  # Диск
  disk {
    size    = "100G"
    type    = "scsi"
    storage = "local-lvm"
    format  = "raw"
  }

  # Сеть
  network {
    model  = "virtio"
    bridge = "vmbr0"
  }

  # IP адрес
  ipconfig0 = "ip=192.168.100.10/24,gw=192.168.100.1"

  # SSH ключ
  sshkeys = var.ssh_public_key

  # Cloud-init
  os_type   = "cloud-init"
  ciuser    = "ubuntu"
  cipassword = var.vm_password

  # Автозапуск при старте Proxmox
  onboot = true
}

resource "proxmox_vm_qemu" "database_vm" {
  name        = "database-vm"
  desc        = "PostgreSQL + Redis + Minio"
  target_node = var.proxmox_node

  clone = var.vm_template

  cores   = 4
  sockets = 1
  memory  = 8192

  disk {
    size    = "200G"
    type    = "scsi"
    storage = "local-lvm"
    format  = "raw"
  }

  network {
    model  = "virtio"
    bridge = "vmbr0"
  }

  ipconfig0 = "ip=192.168.100.20/24,gw=192.168.100.1"

  sshkeys = var.ssh_public_key

  os_type   = "cloud-init"
  ciuser    = "ubuntu"
  cipassword = var.vm_password

  onboot = true
}

resource "proxmox_vm_qemu" "k8s_vm" {
  name        = "k8s-vm"
  desc        = "Single-node Kubernetes cluster"
  target_node = var.proxmox_node

  clone = var.vm_template

  # Гибкие ресурсы в зависимости от окружения
  cores   = var.k8s_cores    # 4 для dev, 16 для prod
  sockets = 1
  memory  = var.k8s_memory   # 8192 для dev, 16384 для prod

  disk {
    size    = "200G"
    type    = "scsi"
    storage = "local-lvm"
    format  = "raw"
  }

  network {
    model  = "virtio"
    bridge = "vmbr0"
  }

  ipconfig0 = "ip=192.168.100.30/24,gw=192.168.100.1"

  sshkeys = var.ssh_public_key

  os_type   = "cloud-init"
  ciuser    = "ubuntu"
  cipassword = var.vm_password

  onboot = true
}

# 1. Инициализация Terraform
cd terraform/
terraform init

# 2. Проверка плана (какие ресурсы будут созданы)
terraform plan

# 3. Применение изменений
terraform apply

# 4. Вывод информации (IP адреса VM)
terraform output

# 5. Удаление всех ресурсов (при необходимости)
terraform destroy

# Подключиться к Proxmox по SSH
ssh root@proxmox-server

# Скачать Ubuntu 22.04 Cloud Image
cd /var/lib/vz/template/iso
wget https://cloud-images.ubuntu.com/jammy/current/jammy-server-cloudimg-amd64.img

# Создать VM template
qm create 9000 --name ubuntu-22.04-template --memory 2048 --net0 virtio,bridge=vmbr0
qm importdisk 9000 jammy-server-cloudimg-amd64.img local-lvm
qm set 9000 --scsihw virtio-scsi-pci --scsi0 local-lvm:vm-9000-disk-0
qm set 9000 --ide2 local-lvm:cloudinit
qm set 9000 --boot c --bootdisk scsi0
qm set 9000 --serial0 socket --vga serial0
qm set 9000 --agent enabled=1

# Конвертировать VM в template
qm template 9000

echo "Template создан с ID: 9000"

# Создание snapshot'а для gitlab-vm
qm snapshot <VM_ID> snap-$(date +%Y%m%d-%H%M%S) --description "GitLab backup"

# Пример через UI:
Proxmox UI → VM → Snapshots → Take Snapshot

# В Proxmox Web UI:
Datacenter → Backup → Add

Настройки:
• Schedule: Daily 02:00
• Storage: local (или NFS/SMB share)
• Mode: Snapshot
• Compression: ZSTD
• Retention: Keep last 7 daily, 4 weekly

# PostgreSQL dump (внутри database-vm)
pg_dumpall -U postgres > /backup/postgres-$(date +%Y%m%d).sql

# GitLab backup (внутри gitlab-vm)
gitlab-backup create

# Kubernetes etcd backup (внутри k8s-vm)
ETCDCTL_API=3 etcdctl snapshot save /backup/etcd-$(date +%Y%m%d).db

• Prometheus + Grafana → Метрики VM (CPU, RAM, Disk I/O)
• Proxmox VE Exporter → Экспорт метрик в Prometheus
• Alertmanager → Уведомления в Telegram при проблемах

Метрики:
- Загрузка CPU > 80%
- Использование RAM > 90%
- Свободное место на диске < 20%
- Время отклика VM > 5 секунд

1. Установить Proxmox VE 8.x на физический сервер
2. Настроить сеть (vmbr0 bridge)
3. Создать cloud-init template Ubuntu 22.04 (ID: 9000)
4. Создать API токен для Terraform

1. Клонировать репозиторий с Terraform конфигурацией
2. Заполнить terraform.tfvars с credentials
3. Выполнить terraform init && terraform apply
4. Дождаться создания 3 VM (gitlab-vm, database-vm, k8s-vm)

1. SSH в gitlab-vm: ssh ubuntu@192.168.100.10
2. Установить Docker Engine
3. Развернуть GitLab CE через Docker Compose
4. Настроить GitLab Runner
5. Включить Container Registry

1. SSH в database-vm: ssh ubuntu@192.168.100.20
2. Установить PostgreSQL 15
3. Создать три базы данных: ksailab, zitadel, gitlab
4. Установить Redis 7
5. Установить Minio (S3-compatible storage)

1. SSH в k8s-vm: ssh ubuntu@192.168.100.30
2. Установить containerd
3. Установить kubeadm, kubelet, kubectl
4. Инициализировать single-node кластер
5. Установить Calico CNI
6. Установить Ingress NGINX Controller
7. Создать namespaces: platform, infrastructure, auth, messaging, labs

Single-node всё:
• 1 Proxmox сервер
• 3 VM (gitlab, database, k8s)
• Single-node Kubernetes
• Единая сеть
• Один PostgreSQL инстанс

Поддерживает: до 50 студентов, 5-10 лабораторных работ одновременно

Добавить отказоустойчивость:
• Multi-node Kubernetes (3 control plane + 2 workers)
• PostgreSQL кластер (Patroni + etcd)
• GitLab HA (несколько runner'ов)
• Сегментированная сеть (VLAN'ы)
• Proxmox Backup Server для off-site бэкапов

Поддерживает: до 200 студентов, 30-50 лабораторных работ одновременно

Масштабирование на несколько серверов:
• Proxmox кластер (3+ узла)
• Ceph/GlusterFS для shared storage
• Kubernetes multi-cluster (ArgoCD для GitOps)
• PostgreSQL с read replicas
• CDN для статики

Поддерживает: 500+ студентов, 100+ одновременных лабораторных работ