Расчет параметров инфраструктуры гибридного хранилища данных

import pandas as pd
import numpy as np

# Класс для расчета параметров инфраструктуры 
# гибридного хранилища данных 
# на виртуальной машине RedHat с PostgreSQL
class infrastructure_requirements:
    # Конструктор класса
    def __init__(
        self, 
        # Параметры данных
        #base_table_size_tb: float = 3.0,  # исходный размер данных (Тб)
        yearly_growth_tb: float = 2.0,    # ожидаемый средний ежегодный прирост данных (Тб)
        hot_years: int = 2,               # количество лет в активном слое (быстрые диски)
        years_to_store: int = 3,          # количество лет, которые требуется хранпить данные (медленные, но надежные диски)
        # Параметры включения компонентов
        include_cold_data: bool = True,   # потребность в исторических (холодных) данных
        include_derived: bool = True,     # потребность в дополнительных слоях (ODS, DDS, CDM)
        include_indexed: bool = True,     # потребность в индексировании
        include_wal: bool = True,         # потребность в оперативном журнале транзакций (Write-Ahead Log, WAL)
        include_wal_archive: bool = True, # потребность в непрерывном архивировании WAL
        include_backups: bool = True,     # потребность в бэкапировании
        include_logs: bool = True,        # потребность в логировании
        include_airflow: bool = True,     # потребность в оркестрации (Airflow)
        include_monitoring: bool = True,  # потребность в мониторинге (Zabbix, Grafana)
        # Параметры размещения
        airflow_on_separate_vm: bool = True,     # размещение Airflow на отдельной ВМ
        monitoring_on_separate_vm: bool = True,  # размещение систем мониторинга на отдельной ВМ
        # Коэфициенты компонентов
        raw_to_derived_coefficient: float = 1.5, # коэффициент прироста размера данных в производных слях (ODS, DDS, CDN)
        index_overhead_coefficient: float = 1.3, # коэффициент прироста размера данных за счет индексов
        backup_multiple: float = .5,             # коэффициент сжатия данных при бэкапировании
        # RAID конфигурации (можно переопределить)
        #raid_configs: Optional[Dict[str, str]] = None, # RAID-конфигурация дисков
        #disk_types: Optional[Dict[str, str]] = None,   # типы дисков
        hdd_raid6_disk_count: int = 8,     # количество дисков RAID6
        # Дополнительные тома
        #additional_volumes: Optional[Dict[str, float]] = None, # дополнительные тома дисков
        # Прочее
        raw_data_download_num: int = 365,  # количество загрузок за год (1 раз в день)
        days_backups: int = 12,            # количество ежедневных бэкапов
        weeks_backups: int = 6,            # количество еженедельных бэкапов
        months_backups: int = 12,          # количество ежемесячных бэкапов
        years_backups: int = 5,            # количество ежегодных бэкапов
        logs_size_tb: float = .2,          # размер диска для логов (Тб)
        system_size_per_vm_tb: float = .1, # размер системных дисков (Тб)
        app_size_tb: float = .1            # размер диска для приложений (Тб)
    ):
        # Базовые параметры
        # Параметры данных
        #self.base_table_size_tb = base_table_size_tb
        self.yearly_growth_tb = yearly_growth_tb
        self.hot_years = hot_years
        self.years_to_store = years_to_store
        # Параметры включения компонентов
        self.include_cold_data = include_cold_data
        self.include_derived = include_derived
        self.include_indexed = include_indexed
        self.include_wal = include_wal
        self.include_wal_archive = include_wal_archive
        self.include_backups = include_backups
        self.include_logs = include_logs
        self.include_airflow = include_airflow
        self.include_monitoring = include_monitoring
        # Параметры размещения
        self.airflow_on_separate_vm = airflow_on_separate_vm
        self.monitoring_on_separate_vm = monitoring_on_separate_vm
        # Коэфициенты компонентов
        self.raw_to_derived_coefficient = raw_to_derived_coefficient
        self.index_overhead_coefficient = index_overhead_coefficient
        self.backup_multiple = backup_multiple
        # RAID конфигурации (можно переопределить)
        #self.raid_configs = raid_configs
        #self.disk_types = disk_types
        self.hdd_raid6_disk_count = hdd_raid6_disk_count
        # Дополнительные тома
        #self.additional_volumes = additional_volumes
        # Прочее
        self.raw_data_download_num = raw_data_download_num
        self.days_backups = days_backups
        self.weeks_backups = weeks_backups
        self.months_backups = months_backups
        self.years_backups = years_backups
        self.logs_size_tb = logs_size_tb
        self.system_size_per_vm_tb = system_size_per_vm_tb
        self.app_size_tb = app_size_tb

        # Базовые параметры проекта в одном датафрейме
        self.basic = pd.DataFrame({
            '':vars(self).keys(),
            'parametr_description':[
                # Параметры данных
                #'Исходный размер данных (Тб)',
                'Ожидаемый средний ежегодный прирост данных (Тб)',
                'Количество лет в активном слое (быстрые диски)',
                'Количество лет, которые требуется хранпить данные (медленные, но надежные диски)',
                # Параметры включения компонентов
                'Потребность в исторических (холодных) данных',
                'Потребность в дополнительных слоях (ODS, DDS, CDM)',
                'Потребность в индексировании',
                'Потребность в оперативном журнале транзакций (Write-Ahead Log, WAL)',
                'Потребность в непрерывном архивировании WAL',
                'Потребность в бэкапировании',
                'Потребность в логировании',
                'Потребность в оркестрации (Airflow)',
                'Потребность в мониторинге (Zabbix, Grafana)',
                # Параметры размещения
                'Размещение Airflow на отдельной ВМ',
                'Размещение систем мониторинга на отдельной ВМР',
                # Коэфициенты компонентов
                'Коэффициент прироста размера данных в производных слях (ODS, DDS, CDN)',
                'Коэффициент прироста размера данных за счет индексов',
                'Коэффициент сжатия данных при бэкапировании',
                # RAID конфигурации (можно переопределить)
                #'RAID-конфигурация дисков',
                #'Типы дисков',
                'Количество дисков RAID6',
                # Дополнительные тома
                #'Дополнительные тома дисков',
                # Прочее
                'Кличество загрузок за год',
                'Количество ежедневных бэкапов',
                'Количество еженедельных бэкапов',
                'Количество ежемесячных бэкапов',
                'Количество ежегодных бэкапов',
                'Размер диска для логов (Тб)',
                'Размер системных дисков (Тб)',
                'Размер диска для приложений (Тб)'
            ],
            'values':vars(self).values()
        }).set_index('')
        
        # Размер данных
        self.calculate_data_size()
        self.data = pd.DataFrame({
            'data_descriptions': self.data_size_descriptions, 
            'data_size': self.data_size
        })
        
        # Размер дискового пространства
        self.calculate_disk_requirements()
        self.disks = pd.DataFrame({
            'disk_descriptions': self.disk_size_descriptions, 
            'disk_type': self.default_disk_type, 
            'disk_raid': self.default_raid, 
            'disk_size': self.disk_size, 
            'disk_iops': self.iops_text
        })
        # Удаление пустых дисков
        self.disks.dropna(subset=['disk_size'], inplace=True)
        # Ранжирование данных по типу диска, RAID и размеру
        self.disks = self.disks.sort_values(by=['disk_type', 'disk_raid', 'disk_size'], ascending=[False, False, False])

        # Размер дисков по типам, RAID, IOPS и виртуальным машинам
        self.vm_disks = self.disks[['disk_type', 'disk_raid', 'disk_size', 'disk_iops']].groupby(['disk_type', 'disk_raid', 'disk_iops']).sum('disk_size').reset_index()
        self.vm_disks['vm'] = 'dlh'
        # Диски для Airflow и мониторинга
        vm = pd.DataFrame(index=['vm', 'disk_type', 'disk_raid', 'disk_size', 'disk_iops'])
        # Если требуется Airflow
        if self.include_airflow:
            vm = self.disks.loc[['logs', 'system', 'app'], ['disk_type', 'disk_raid', 'disk_size', 'disk_iops']].groupby(['disk_type', 'disk_raid', 'disk_iops']).sum('disk_size').reset_index()
            # размещение Airflow на отдельной ВМ
            if self.airflow_on_separate_vm:
                vm['vm'] = 'airflow'
                self.vm_disks = pd.concat([self.vm_disks, vm], ignore_index=True)
            else:
                vm['vm'] = self.vm_disks.loc[0, 'vm'] + '_airflow'
                self.vm_disks.loc[self.vm_disks['vm'].str.contains('dlh'), 'vm'] = self.vm_disks.loc[self.vm_disks['vm'].str.contains('dlh'), 'vm'] + '_airflow'
                self.vm_disks = pd.concat([self.vm_disks, vm], ignore_index=True)
                self.vm_disks = self.vm_disks.groupby(['vm', 'disk_type', 'disk_raid', 'disk_iops']).sum('disk_size').reset_index()
        # Если требуется мониторинг
        if self.include_monitoring:
            vm = self.disks.loc[['logs', 'system', 'app'], ['disk_type', 'disk_raid', 'disk_size', 'disk_iops']].groupby(['disk_type', 'disk_raid', 'disk_iops']).sum('disk_size').reset_index()
            # размещение систем мониторинга на отдельной ВМ
            if self.monitoring_on_separate_vm:
                vm['vm'] = 'zabbix_grafana'
                self.vm_disks = pd.concat([self.vm_disks, vm], ignore_index=True)
            else:
                vm['vm'] = self.vm_disks.loc[0, 'vm'] + '_zabbix_grafana'
                self.vm_disks.loc[self.vm_disks['vm'].str.contains('dlh'), 'vm'] = self.vm_disks.loc[self.vm_disks['vm'].str.contains('dlh'), 'vm'] + '_zabbix_grafana'
                self.vm_disks = pd.concat([self.vm_disks, vm], ignore_index=True)
                self.vm_disks = self.vm_disks.groupby(['vm', 'disk_type', 'disk_raid', 'disk_iops']).sum('disk_size').reset_index()
        # Ранжирование параметров датафрейма
        self.vm_disks = self.vm_disks[['vm', 'disk_type', 'disk_raid', 'disk_size', 'disk_iops']]
        # Ранжирование данных по виртуальной машине, типу диска, RAID и размеру
        self.vm_disks = self.vm_disks.sort_values(by=['vm', 'disk_type', 'disk_raid', 'disk_size'], ascending=[True, False, False, False])

        # Уменьшение количества знаков в мантисе значений 'data_size' и 'disk_size' датафреймов
        self.data['data_size'] = self.data['data_size'].round(2)
        self.disks['disk_size'] = self.disks['disk_size'].round(2)
        self.vm_disks['disk_size'] = self.vm_disks['disk_size'].round(2)
        
        # Снятие ограничение на ширину столбцов датафрейма
        pd.set_option('display.max_colwidth', None)

    # Размер данных
    def calculate_data_size(self):
        # Свежие сырые данные, помещаемые в слой STG за одну итерацию
        frash_raw_tb = self.yearly_growth_tb / self.raw_data_download_num
        self.data_size = {'frash_raw': frash_raw_tb}
        self.data_size_descriptions = {'frash_raw': 'Свежие сырые данные'}
        
        # Горячие сырые данные (активные), хранящиеся в RTG
        hot_raw_tb = frash_raw_tb + (self.yearly_growth_tb * self.hot_years)
        self.data_size['hot_raw'] = hot_raw_tb
        self.data_size_descriptions['hot_raw'] = 'Горячие сырые данные'
        
        # Холодные сырые данные (архивные), хранящиеся в RTG
        #total_raw_tb = self.base_table_size_tb + (self.years_to_store - 1) * self.yearly_growth_tb
        cold_raw_tb = self.yearly_growth_tb * self.years_to_store
        self.data_size['cold_raw'] = cold_raw_tb
        self.data_size_descriptions['cold_raw'] = 'Холодные сырые данные'
        
        # Все сырые данные (архивные), хранящиеся в RTG
        #total_raw_tb = self.base_table_size_tb + (self.years_to_store - 1) * self.yearly_growth_tb
        total_raw_tb = hot_raw_tb + cold_raw_tb
        self.data_size['total_raw'] = total_raw_tb
        self.data_size_descriptions['total_raw'] = 'Все сырые данные'
        
        # Сырые и производные данные (слои ODS, DDS, витрины) без индексов
        # (если требуются дополнительные слои)
        if self.include_derived:
            derived_tb = total_raw_tb * self.raw_to_derived_coefficient
            self.data_size['derived'] = derived_tb
            self.data_size_descriptions['derived'] = 'Сырые и производные данные'
        else:
            derived_tb = total_raw_tb
    
        # Сырые и производные данные с индексами 
        # (индексы занимают дополнительное место)
        if self.include_indexed:
            indexed_tb = derived_tb * self.index_overhead_coefficient
            self.data_size['indexed'] = indexed_tb
            self.data_size_descriptions['indexed'] = 'Сырые и производные данные с индексами'
        else:
            indexed_tb = derived_tb
        
        # Активные данные
        hot_data_tb = hot_raw_tb
        if self.include_derived:
            hot_data_tb = hot_data_tb * self.raw_to_derived_coefficient
        if self.include_indexed:
            hot_data_tb = hot_data_tb * self.index_overhead_coefficient
        self.data_size['hot_data'] = hot_data_tb
        self.data_size_descriptions['hot_data'] = 'Активные данные'
        
        # Исторические данные
        if self.include_cold_data:
            cold_data_tb = cold_raw_tb
            if self.include_derived:
                hot_data_tb = hot_data_tb * self.raw_to_derived_coefficient
            if self.include_indexed:
                hot_data_tb = hot_data_tb * self.index_overhead_coefficient
            self.data_size['cold_data'] = cold_data_tb
            self.data_size_descriptions['cold_data'] = 'Исторические данные'
        
        # WAL
        if self.include_wal:
            # Оценка WAL: обычно ~10% от годовой записи или фиксированный запас.
            # Возьмём как 0.2 ТБ (200 ГБ) + небольшой запас.
            self.data_size["wal"] = .2
            self.data_size_descriptions["wal"] = 'WAL (оперативный журнал транзакций, Write-Ahead Log)'
            # WAL архив (непрерывное архивирование)
            if self.include_wal_archive:
                # Пусть будет 0.5 ТБ (500 ГБ) для хранения 2 недель архива при интенсивной загрузке
                self.data_size["wal_archive"] = .5
                self.data_size_descriptions["wal_archive"] = 'Архив WAL'
    
        # Бэкапы
        if self.include_backups:
            # Обычно бэкапы занимают примерно backup_multiple от общего объёма (с учётом сжатия)
            # Для упрощения: берём indexed_tb * backup_multiple
            # Но в реальности политика может быть сложнее.
            self.data_size["backups"] = indexed_tb * self.backup_multiple * (self.days_backups + self.weeks_backups + self.months_backups + self.years_backups)
            self.data_size_descriptions["backups"] = 'Бэкап'
    
        # Логи
        if self.include_logs:
            self.data_size["logs"] = self.logs_size_tb
            self.data_size_descriptions["logs"] = 'Логи'

        # Системные тома (под ОС каждой ВМ)
        # По умолчанию предполагаем 3 ВМ: БД, Airflow, мониторинг
        self.data_size["system"] = self.system_size_per_vm_tb
        self.data_size_descriptions["system"] = 'Системные тома (под ОС каждой ВМ)'
        
        # Том для приложений (Airflow, скрипты)
        self.data_size["app"] = self.app_size_tb
        self.data_size_descriptions["app"] = 'Том для приложений (Airflow, скрипты)'
        
        # Дополнительные тома (если указаны)
        '''
        if self.additional_volumes:
            for name, size in self.additional_volumes.items():
                self.data_size[f"additional_{name}_tb"] = size
                self.data_size_descriptions[f"additional_{name}_tb"] = f'Дополнительный том {name}'
        '''

    # Размер дискового пространства
    def calculate_disk_requirements(self):
        # Значения по умолчанию для RAID, 
        # типов дисков (можно переопределить через параметры)
        # и коэффициенты эеективности дисков в зависимости от RAID
        self.default_disk_type = {
            "hot_data": "SSD",
            "cold_data": "HDD",
            "wal": "SSD",
            "wal_archive": "HDD", #"SSD or HDD",
            "backups": "HDD",
            "logs": "SSD",
            "system": "SSD",
            "app": "SSD",
        }
        self.default_raid = {
            "hot_data": "RAID10",
            "cold_data": "RAID6",
            "wal": "RAID10",
            "wal_archive": "RAID10",
            "backups": "RAID6",
            "logs": "RAID1",
            "system": "RAID1",
            "app": "RAID1",
        }
        self.raid_efficiency = {
            "RAID0": 1., # использует весь объём дисков без резервирования
            "RAID1": .5, # данные полностью дублируются на пары дисков
            "RAID6": (self.hdd_raid6_disk_count - 2.) / self.hdd_raid6_disk_count, # фактически не используется 2 диска из массива RAID6
            "RAID10": .5, # фактический объём составляет примерно половину суммарного объёма дисков
        }

        # Расчет размера дисков
        self.disk_size = {}
        self.disk_size_descriptions = {}
        for i in self.default_disk_type:
            if i in self.data_size:
                raid = self.default_raid[i]
                self.disk_size[i] = self.data_size[i] / self.raid_efficiency[raid]
                self.disk_size_descriptions[i] = self.data_size_descriptions[i]
        
        # IOPS в зависимости от типа диска и назначения
        self.iops_text = {
            "hot_data": "Высокие IOPS (случайная запись/чтение), требуется низкая задержка",
            "cold_data": "Низкие IOPS (редкие запросы)",
            "wal": "Высокие IOPS (случайная запись/чтение), требуется низкая задержка",
            "wal_archive": "Высокие IOPS (случайная запись/чтение), требуется низкая задержка",
            "backups": "Низкие IOPS, важна пропускная способность при записи/чтении",
            "logs": "Умеренные IOPS",
            "system": "Умеренные IOPS",
            "app": "Умеренные IOPS",
        }
        self.iops_text = {
            "hot_data": "Высокие (не менее 5000, но лучше 10000+) IOPS (случайная запись/чтение), низкая задержка, пропускная способность не менее 500 МБ/с на последовательное чтение/запись",
            "cold_data": "Низкие (достаточно 500-1000) IOPS (редкие запросы), пропускная способность 100-200 МБ/с",
            "wal": "Высокие (в пределах 1000-2000) IOPS (случайная запись/чтение), низкая задержка (должна быть < 1 мс)",
            "wal_archive": "Высокие IOPS (случайная запись/чтение), низкая задержка",
            "backups": "Низкие IOPS, важна пропускная способность при записи/чтении",
            "logs": "Умеренные IOPS",
            "system": "Умеренные IOPS",
            "app": "Умеренные IOPS",
        }

    # Демонстрация результатов работы класса
    def print(self):
        print('\n', '='*5, 'Заданные параметры инфраструктуры', '='*5)
        display(self.basic)
        print('\n', '='*5, 'Размер данных (Тб)', '='*5)
        display(self.data)
        print('\n', '='*5, 'Дисковое пространство (Тб)', '='*5)
        display(self.disks)
        print('\n', '='*5, 'Размер дисков (Тб) по типам, RAID, IOPS и виртуальным машинам', '='*5)
        display(self.vm_disks)