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

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,          # количество ежемесячных бэкапов
        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.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 include_airflow:
            vm = self.disks[['disk_type', 'disk_raid', 'disk_size', 'disk_iops']].iloc[5:, :].groupby(['disk_type', 'disk_raid', 'disk_iops']).sum('disk_size').reset_index()
            # размещение Airflow на отдельной ВМ
            if 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 include_monitoring:
            vm = self.disks[['disk_type', 'disk_raid', 'disk_size', 'disk_iops']].iloc[5:, :].groupby(['disk_type', 'disk_raid', 'disk_iops']).sum('disk_size').reset_index()
            # размещение систем мониторинга на отдельной ВМ
            if 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.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)