Используется всеми профилями (B1-B10). Меняется только vcpu_pcpu_ratio (A1.cpu.*).
Источники: Nutanix Sizer, HPE ESP Online Sizer, Cisco UCS Sizer, VMware vSizer
pCores_raw = CEILING( total_vCPU / vcpu_pcpu_ratio )
pCores_headroom = pCores_raw * A1.hm.cpu
sockets_needed = CEILING( pCores_headroom / cores_per_socket )
nodes_by_cpu = CEILING( sockets_needed / sockets_per_node )
concurrent_users = total_users * concurrency_ratio
cpu_per_server = CEILING( memory_per_server_GB / 4 )
Источники: Nutanix Sizer (CVM overhead), ProcessMaker Sizing Guide (peak user formula),
ECOSIRE ERP Sizer (Odoo: 150 MB/concurrent user), VMware vSphere best practices
vm_ram_total_GB = SUM(vm_ram_per_workload_GB)
cvm_overhead_GB = cvm_ram_per_node_GB * estimated_nodes
ram_raw_GB = vm_ram_total_GB + cvm_overhead_GB + (os_overhead_GB * estimated_nodes)
ram_headroom_GB = ram_raw_GB * A1.hm.ram
ram_per_node_GB_raw = ram_headroom_GB / nodes_total
ram_per_node_GB = CEILING(ram_per_node_GB_raw / dimm_GB) * dimm_GB
dimm_count = CEILING( ram_per_node_GB / dimm_capacity_GB )
tm = (peak_users * mb_per_user * A1.hm.peak_users) / 1024
sc = CEILING( (tm * redundancy_level) / max_ram_per_server_GB )
ram_per_server_GB = CEILING( (tm * redundancy_level) / sc / 8 ) * 8
Источники: Nutanix Sizer, NetApp Sizing, Pure Storage Sizer, VMware vSAN Sizer,
HPE Nimble/Primera Sizer, ECOSIRE ERP (NVMe required 50+ users)
raw_capacity_TB = usable_TB * RF / (dedup_ratio * compress_ratio)
ssd_hot_tier_TB = active_working_set_TB * 1.10
nodes_by_storage = CEILING( raw_capacity_TB / raw_per_node_TB )
data_drives_per_node = CEILING( raw_per_node_TB / drive_capacity_TB )
storage_future_TB = current_usable_TB * (1 + annual_growth_rate)^planning_years
db_growth_GB_year = 1..5 * (active_users / 10)
total_db_GB = initial_db_GB + db_growth_GB_year * planning_years
total_storage_GB = total_db_GB * 2.5
Источники: NetApp Performance Sizing, VMware vSAN IOPS Model, HPE Nimble Sizing
throughput_MBps = IOPS * block_size_KB / 1024
vsan_read_iops = nodes * drives_per_node * drive_iops * read_pct
vsan_write_iops = nodes * drives_per_node * drive_iops * write_pct / RF
vsan_total_iops = vsan_read_iops + vsan_write_iops
min_drives_for_iops = CEILING( required_iops / drive_iops )
Источники: Nutanix Sizer (replication traffic), ProcessMaker (gigabit LAN requirement),
NVIDIA DGX Configurator (InfiniBand для AI)
vm_bw_total_Gbps = sum_vm_count * avg_bw_per_vm_Gbps
uplinks_needed = CEILING( vm_bw_total_Gbps / nic_port_speed_Gbps )
storage_bw_Gbps = write_iops * block_size_KB / 1024 / 125 * RF
allreduce_bw_GBps = 2 * (gpu_count - 1) / gpu_count * model_params_B * 2
backup_bw_Gbps = daily_changed_data_GB / (backup_window_hours * 3600) * 8
Источники: NVIDIA DGX Configurator, HuggingFace Model Memory Calculator,
Basebox AI VRAM Guide, vLLM docs, llama.cpp performance benchmarks
vram_weights_GB = model_params_B * precision_bytes * A1.hm.gpu_vram
kv_cache_GB = 2 * num_layers * num_heads * head_dim * max_seq_len * batch_size * precision_bytes / 1e9
vram_total_GB = vram_weights_GB + kv_cache_GB + activation_overhead_GB
gpu_count_min = CEILING( vram_total_GB / gpu_vram_GB )
tokens_per_sec = gpu_count * gpu_mem_bw_GBs * 1e9 / (model_params_B * precision_bytes * 1e9)
concurrent_sessions = FLOOR( available_vram_GB / per_session_vram_GB )
gpu_servers = CEILING( gpu_count_min / gpus_per_server )
Источники: HPE Power Advisor, Dell EMC OpenManage Power Manager, ASHRAE TC 9.9
server_tdp_W = (cpu_tdp_W * sockets)
+ (dimm_count * A1.pwr.dimm_w)
+ (total_drives * A1.pwr.drive_w)
+ nic_tdp_W
+ gpu_tdp_W
+ A1.pwr.base_w
psu_capacity_W >= server_tdp_W * 1.20
rack_power_W = SUM(server_tdp_W) + switch_power_W + pdu_losses_W
cooling_BTU_h = rack_power_W * A1.pwr.btu_coeff
facility_W = rack_power_W * PUE_factor
annual_kwh = facility_W / 1000 * 8760
annual_power_cost = annual_kwh * electricity_rate_per_kwh
Только необходимая мощность. Отказ любого компонента = немедленный простой.
ЗАПРЕЩЁН для production без DR-плана.
0
99.0
87.6
{{MTTR_H_NO_REDUND}}
Отказ одного диска → потеря данных (без RAID/RF)
Отказ сервера → полный простой сервиса
Отказ питания → аварийное отключение
annual_risk_cost = annual_downtime_h * downtime_cost_per_h * probability_factor
Один запасной компонент на каждую критическую систему.
Стандарт для Tier II/III. Допускает обслуживание без простоя.
20
99.9
8.7
PSU | Fan | NIC | Uplink | HBA | Switch | Node (N+1 in cluster)
Полная зеркальная копия каждой системы. Tier III/IV DC standard.
Каждая система работает параллельно или в hot-standby.
80
99.99
0.87
Power paths | Cooling | Network paths | Storage controllers
Два независимых N+1 контура. Tier IV. Допускает одновременный отказ
одного компонента в каждом контуре.
150
99.999
0.09
Mission-critical: финансовые системы, healthcare, telecom core
expected_annual_downtime_h = failure_probability_annual * avg_repair_time_h
annual_risk_cost_USD = expected_annual_downtime_h
* (A1.dt.revenue_hour_usd + A1.dt.staff_cost_hour)
* A1.dt.reputation_mult
redundancy_roi_years = redundancy_capex_overhead_USD / annual_risk_cost_USD
daily_changed_GB = protected_data_GB * daily_change_rate_pct / 100
backup_raw_GB = full_backup_GB
+ (daily_changed_GB * incrementals_count)
+ (full_backup_GB * full_copies_count)
backup_effective_GB = backup_raw_GB / (A1.dc.backup_dedup * A1.dc.backup_comp)
backup_capacity_TB = backup_effective_GB * retention_weeks * 7 / 1024 * headroom_1.2
required_bw_Gbps = daily_changed_GB * 8 / (backup_window_hours * 3600)
rpo_hours = MIN(mad_hours, backup_interval_hours)
data_loss_GB = daily_changed_GB * (backup_interval_hours / 24)
Полное время восстановления складывается из технических задержек (сеть, диск)
и человеческих факторов (диагностика, эскалация, вендор, верификация).
Источник: Axcient RTO Calculator, Fidalia DR Time Calculator, Kelser RTO Tool
t_network_hours = restore_data_GB / (restore_bw_Gbps * 125)
t_disk_write_hours = restore_data_GB / (disk_write_speed_MBps * 3.6)
t_human_hours = ( A1.hf.triage_min
+ A1.hf.escalate_min
+ A1.hf.l2_response_min
+ t_vendor_response_min
+ t_parts_logistics_min
+ t_hw_replacement_min
+ t_os_reinstall_min
+ t_restore_verification_min
) / 60
rto_total_hours = t_network_hours
+ t_disk_write_hours
+ t_human_hours
+ t_app_startup_hours
rto_failover_hours = t_human_hours * 0.3
rto_cost_USD = rto_total_hours
* (A1.dt.revenue_hour_usd + A1.dt.staff_cost_hour)
* A1.dt.reputation_mult
Veeam Instant Recovery | Zerto CJR | Active-Active cluster
Same-site all-flash replica
10+ Gbps local, synchronous replication
2.0x
Автоматический failover; A10.3.5 применяется; DR test ежеквартально
Veeam SOBR + offsite | Nakivo | Acronis Cyber Backup
Local fast disk + cloud or remote site
1+ Gbps, async replication interval ≤15 min
1.4x
A10.3.1–A10.3.4 применяется; restore from local cache
Veeam B&R | Bacula | Amanda | Restic | Duplicati
Local NAS + tape or cloud (S3/glacier)
100+ Mbps; restore via WAN acceptable
1.1x
Full RTO formula A10.3.4 применяется; требует выездного инженера при HW failure
Tape (LTO-9) | S3 Glacier | Disk-to-tape
Tape library | Glacier Deep Archive
Minimal; restore может занимать 24-72h
1.0x
Только для non-critical data; NBD vendor support достаточен
capex_hw_USD = SUM(unit_price_USD * quantity) for all hardware BOM items
capex_sw_USD = SUM(perpetual_license_price * license_count)
capex_net_USD = SUM(switch_price + cables + SFP_price)
capex_facility_USD = rack_price + pdu_price + cabling + cooling_upgrade
capex_impl_USD = engineer_days * day_rate_USD + migration_tool_cost
total_capex_USD = capex_hw + capex_sw + capex_net + capex_facility + capex_impl
capex_redundancy_USD = total_capex_baseline * redundancy_overhead_pct / 100
opex_power_USD = facility_W / 1000 * 8760 * electricity_rate_USD_per_kWh
opex_sw_USD = SUM(annual_subscription_price * license_count)
opex_hw_maint_USD = total_capex_hw * maintenance_rate_pct / 100
opex_staff_USD = fte_count * avg_salary_USD * employer_overhead_mult
opex_colo_USD = rack_count * monthly_rack_rent_USD * 12
total_opex_annual_USD = opex_power + opex_sw + opex_hw_maint + opex_staff + opex_colo
tco_USD = total_capex_USD + (total_opex_annual_USD * tco_years)
cost_per_vm_year = tco_USD / tco_years / total_vm_count
cost_per_vcpu_year = tco_USD / tco_years / total_vcpu
cost_per_tb_year = tco_USD / tco_years / total_usable_tb
annual_savings_USD = baseline_annual_cost_USD - total_opex_annual_USD
roi_pct = (annual_savings_USD * tco_years - total_capex_USD)
/ total_capex_USD * 100
payback_years = total_capex_USD / annual_savings_USD
npv_USD = SUM[ annual_savings_USD / (1 + discount_rate)^t for t in 1..N ]
- total_capex_USD
redundancy_roi_years = capex_redundancy_USD / annual_risk_cost_USD
A2 A3 A4 A5 A6 A8 A9 A10 A11
A2 A3 A4 A5 A6 A8 A9 A10 A11
desktop_vcpu = 2..4 per desktop (type: task|knowledge|power)
desktop_ram_GB = 2..8 per desktop
desktop_storage_GB = 20..80 per desktop (persistent) | 5..15 (non-persistent)
concurrent_sessions = total_desktops * concurrency_ratio
A2 A3 A4 A5 A6 A8 A9 A10 A11
buffer_pool_GB = active_dataset_GB * 1.25
olap_ram_GB = MAX( table_size_GB * 2, compressed_columnstore_GB * 3 )
log_volume_GB = daily_transaction_GB * 3
db_iops = tps * avg_io_per_transaction
A2 A3 A4 A5 A6 A8 A9 A10 A11
server_count = CEILING( (tm * rl) / max_ram_per_server_GB )
redis_ram_GB = hot_data_GB * 1.5
A2 A3 A4 A5 A6 A8 A9 A10 A11
hana_ram_GB = compressed_column_store_GB * 3
hana_total_ram_GB = hana_ram_GB * 1.5
hana_persist_GB = hana_ram_GB * 1.5
hana_backup_GB = hana_persist_GB * backup_copies * (1 / dedup_ratio)
A2 A3 A4 A5 A6 A8 A9 A10 A11
mailbox_storage_GB = mailbox_count * mailbox_size_GB * 1.20
exchange_db_overhead = mailbox_storage_GB * 1.10
dag_copies = 2..4
dag_storage_TB = exchange_db_GB * dag_copies / 1024
A2 A7 A8 A9 A10 A11
gpu_count_latency = CEILING( vram_total_GB / gpu_vram_GB )
gpu_count_throughput = CEILING( target_rps * avg_latency_s / concurrent_slots )
gpu_count_final = MAX( gpu_count_latency, gpu_count_throughput )
tp_degree = gpu_count if NVLink else 1..2
A2 A7 A8 A9 A10 A11
vram_full_train_GB = model_params_B * 16
vram_lora_GB = model_params_B * 2 + lora_rank * model_hidden_dim * num_layers * 4
vram_qlora_GB = model_params_B * 0.5 + lora_overhead_GB
training_samples_per_sec = gpu_count * batch_size_per_gpu * gradient_accumulation
effective_batch = batch_size_per_gpu * gpu_count * gradient_accumulation
min_ib_bw_GBps = 2 * (N-1)/N * model_params_B * 2 / iteration_time_s
A2 A3 A4 A5 A6 A8 A9 A10 A11
node_count = CEILING( total_core_hours / (cores_per_node * job_wall_hours) )
parallel_efficiency_pct = amdahl_speedup_factor * 100
scratch_TB = peak_checkpoint_size_GB * simultaneous_jobs / 1024
A2 A3 A4 A8 A9 A10 A11
edge_cpu_cores = concurrent_inference_streams * cores_per_stream
edge_ram_GB = model_vram_GB + os_overhead_GB + buffer_GB
edge_storage_GB = model_size_GB + data_buffer_days * daily_data_GB
local_fallback = heartbeat_based_failover OR manual_intervention
sync_interval_min = acceptable_rpo_min