7.3 高可用性とスケーリング ​

#!/usr/bin/env python3
# Zabbix Server Performance Tuner

import psutil
import subprocess
import configparser
import math

class ZabbixPerformanceTuner:
    def __init__(self, config_file="/etc/zabbix/zabbix_server.conf"):
        self.config_file = config_file
        self.system_info = self._get_system_info()
    
    def _get_system_info(self):
        """システム情報取得"""
        return {
            'cpu_cores': psutil.cpu_count(),
            'memory_gb': psutil.virtual_memory().total / (1024**3),
            'disk_io': psutil.disk_io_counters(),
            'network_io': psutil.net_io_counters()
        }
    
    def calculate_optimal_settings(self, host_count, item_count):
        """最適設定値の計算"""
        cpu_cores = self.system_info['cpu_cores']
        memory_gb = self.system_info['memory_gb']
        
        # ベースライン計算
        base_pollers = min(200, max(10, host_count // 20))
        pollers = min(base_pollers, cpu_cores * 10)
        
        # メモリベース設定
        cache_size = min(int(memory_gb * 0.3), 8) * 1024  # MB
        history_cache = min(int(memory_gb * 0.15), 4) * 1024  # MB
        trend_cache = min(int(memory_gb * 0.1), 2) * 1024  # MB
        value_cache = min(int(memory_gb * 0.2), 16) * 1024  # MB
        
        # アイテム数ベース設定
        trappers = min(100, max(10, item_count // 1000))
        db_syncers = min(16, max(4, cpu_cores // 2))
        
        return {
            'StartPollers': pollers,
            'StartPollersUnreachable': max(5, pollers // 5),
            'StartTrappers': trappers,
            'StartDBSyncers': db_syncers,
            'CacheSize': f"{cache_size}M",
            'HistoryCacheSize': f"{history_cache}M",
            'TrendCacheSize': f"{trend_cache}M",
            'ValueCacheSize': f"{value_cache}M"
        }
    
    def apply_settings(self, settings):
        """設定の適用"""
        config = configparser.ConfigParser()
        config.read(self.config_file)
        
        # バックアップ作成
        subprocess.run(['cp', self.config_file, f"{self.config_file}.backup"])
        
        # 設定更新
        if 'DEFAULT' not in config.sections():
            config.add_section('DEFAULT')
        
        for key, value in settings.items():
            config.set('DEFAULT', key, str(value))
        
        # 設定保存
        with open(self.config_file, 'w') as f:
            config.write(f)
        
        print(f"Settings applied to {self.config_file}")
        print("Please restart Zabbix server to apply changes")
    
    def monitor_performance(self):
        """パフォーマンス監視"""
        # Zabbixプロセス統計
        zabbix_processes = []
        for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_info']):
            if 'zabbix' in proc.info['name']:
                zabbix_processes.append(proc.info)
        
        # システムメトリクス
        cpu_usage = psutil.cpu_percent(interval=1)
        memory = psutil.virtual_memory()
        disk_io = psutil.disk_io_counters()
        
        return {
            'zabbix_processes': len(zabbix_processes),
            'cpu_usage': cpu_usage,
            'memory_usage': memory.percent,
            'memory_available': memory.available / (1024**3),
            'disk_read_mb': disk_io.read_bytes / (1024**2),
            'disk_write_mb': disk_io.write_bytes / (1024**2)
        }

# 使用例
tuner = ZabbixPerformanceTuner()
optimal_settings = tuner.calculate_optimal_settings(host_count=5000, item_count=50000)
tuner.apply_settings(optimal_settings)

#!/usr/bin/env python3
# Zabbix Capacity Planning Calculator

class ZabbixCapacityPlanner:
    def __init__(self):
        # ベースサイズ（バイト）
        self.history_record_size = 90  # 履歴レコード
        self.trend_record_size = 128   # トレンドレコード
        self.event_record_size = 512   # イベントレコード
        
    def calculate_storage_requirements(self, hosts, items_per_host, 
                                     history_retention_days=30,
                                     trend_retention_days=365):
        """ストレージ要件の計算"""
        
        total_items = hosts * items_per_host
        
        # 1日あたりのデータポイント（1分間隔想定）
        data_points_per_day = total_items * 1440  # 24 * 60
        
        # 履歴データサイズ
        history_daily_size = data_points_per_day * self.history_record_size
        history_total_size = history_daily_size * history_retention_days
        
        # トレンドデータサイズ（1時間間隔）
        trend_daily_size = (total_items * 24) * self.trend_record_size
        trend_total_size = trend_daily_size * trend_retention_days
        
        # イベントデータサイズ（想定：1ホストあたり5イベント/日）
        events_daily_size = hosts * 5 * self.event_record_size
        events_total_size = events_daily_size * history_retention_days
        
        # 設定データ（テンプレート、ホスト、アイテムなど）
        config_size = (hosts * 50 * 1024) + (total_items * 2 * 1024)  # 概算
        
        # 合計サイズ
        total_size = (history_total_size + trend_total_size + 
                     events_total_size + config_size)
        
        return {
            'hosts': hosts,
            'total_items': total_items,
            'data_points_per_day': data_points_per_day,
            'history_size_gb': history_total_size / (1024**3),
            'trend_size_gb': trend_total_size / (1024**3),
            'events_size_gb': events_total_size / (1024**3),
            'config_size_gb': config_size / (1024**3),
            'total_size_gb': total_size / (1024**3),
            'daily_growth_gb': (history_daily_size + trend_daily_size + 
                               events_daily_size) / (1024**3)
        }
    
    def calculate_server_requirements(self, hosts, items_per_host):
        """サーバー要件の計算"""
        
        total_items = hosts * items_per_host
        nvps = total_items / 60  # New Values Per Second
        
        # CPU要件（経験的数値）
        cpu_cores = max(4, int(nvps / 1000) * 2)
        
        # メモリ要件
        base_memory = 4  # GB
        cache_memory = (total_items * 150) / (1024**3)  # 150バイト/アイテム
        total_memory = base_memory + cache_memory
        
        # ネットワーク要件
        network_mbps = (nvps * 50 * 8) / (1024**2)  # 50バイト/値
        
        # ディスクI/O要件
        disk_iops = nvps * 2  # 書き込み + インデックス更新
        
        return {
            'nvps': nvps,
            'cpu_cores': cpu_cores,
            'memory_gb': total_memory,
            'network_mbps': network_mbps,
            'disk_iops': disk_iops,
            'recommended_memory_gb': total_memory * 1.5,  # 余裕を見る
            'recommended_cpu_cores': cpu_cores * 1.2
        }
    
    def generate_scaling_plan(self, current_hosts, target_hosts, 
                            growth_period_months=12):
        """スケーリング計画の生成"""
        
        monthly_growth = (target_hosts - current_hosts) / growth_period_months
        
        scaling_plan = []
        for month in range(1, growth_period_months + 1):
            projected_hosts = current_hosts + (monthly_growth * month)
            
            storage_req = self.calculate_storage_requirements(
                int(projected_hosts), 50  # 50アイテム/ホスト想定
            )
            server_req = self.calculate_server_requirements(
                int(projected_hosts), 50
            )
            
            scaling_plan.append({
                'month': month,
                'hosts': int(projected_hosts),
                'storage_gb': storage_req['total_size_gb'],
                'memory_gb': server_req['recommended_memory_gb'],
                'cpu_cores': server_req['recommended_cpu_cores'],
                'nvps': server_req['nvps']
            })
        
        return scaling_plan

# 使用例
planner = ZabbixCapacityPlanner()

# 現在の要件計算
current_req = planner.calculate_storage_requirements(
    hosts=1000, 
    items_per_host=50
)

print("Current Storage Requirements:")
print(f"Total Size: {current_req['total_size_gb']:.2f} GB")
print(f"Daily Growth: {current_req['daily_growth_gb']:.2f} GB")

# サーバー要件計算
server_req = planner.calculate_server_requirements(
    hosts=1000, 
    items_per_host=50
)

print("\nServer Requirements:")
print(f"CPU Cores: {server_req['recommended_cpu_cores']:.0f}")
print(f"Memory: {server_req['recommended_memory_gb']:.1f} GB")
print(f"NVPS: {server_req['nvps']:.0f}")

# スケーリング計画
scaling_plan = planner.generate_scaling_plan(
    current_hosts=1000,
    target_hosts=5000,
    growth_period_months=12
)

print("\nScaling Plan (Next 12 months):")
for plan in scaling_plan[::3]:  # 3ヶ月ごとに表示
    print(f"Month {plan['month']}: {plan['hosts']} hosts, "
          f"{plan['storage_gb']:.0f}GB storage, "
          f"{plan['memory_gb']:.0f}GB RAM")

#!/usr/bin/env python3
# Zabbix Cluster Health Monitor

import requests
import json
import subprocess
import time
from datetime import datetime

class ZabbixClusterMonitor:
    def __init__(self, nodes, check_interval=60):
        self.nodes = nodes
        self.check_interval = check_interval
        self.results = {}
    
    def check_node_health(self, node):
        """ノードのヘルスチェック"""
        health_status = {
            'node': node['name'],
            'timestamp': datetime.now().isoformat(),
            'status': 'unknown',
            'checks': {}
        }
        
        try:
            # Zabbixサーバープロセスチェック
            health_status['checks']['process'] = self._check_process(node)
            
            # ポートチェック
            health_status['checks']['port'] = self._check_port(node)
            
            # API応答チェック
            health_status['checks']['api'] = self._check_api(node)
            
            # データベース接続チェック
            health_status['checks']['database'] = self._check_database(node)
            
            # リソース使用率チェック
            health_status['checks']['resources'] = self._check_resources(node)
            
            # 全体ステータス判定
            all_checks = [health_status['checks'][key]['status'] 
                         for key in health_status['checks']]
            
            if all(status == 'ok' for status in all_checks):
                health_status['status'] = 'healthy'
            elif any(status == 'critical' for status in all_checks):
                health_status['status'] = 'critical'
            else:
                health_status['status'] = 'warning'
                
        except Exception as e:
            health_status['status'] = 'error'
            health_status['error'] = str(e)
        
        return health_status
    
    def _check_process(self, node):
        """プロセスチェック"""
        try:
            result = subprocess.run(
                ['ssh', node['host'], 'pgrep -f zabbix_server'],
                capture_output=True, text=True, timeout=10
            )
            return {
                'status': 'ok' if result.returncode == 0 else 'critical',
                'detail': 'Process running' if result.returncode == 0 else 'Process not found'
            }
        except Exception as e:
            return {'status': 'error', 'detail': str(e)}
    
    def _check_port(self, node):
        """ポートチェック"""
        try:
            result = subprocess.run(
                ['nc', '-z', node['host'], '10051'],
                capture_output=True, timeout=5
            )
            return {
                'status': 'ok' if result.returncode == 0 else 'critical',
                'detail': 'Port accessible' if result.returncode == 0 else 'Port not accessible'
            }
        except Exception as e:
            return {'status': 'error', 'detail': str(e)}
    
    def _check_api(self, node):
        """API応答チェック"""
        try:
            response = requests.post(
                f"http://{node['host']}/zabbix/api_jsonrpc.php",
                json={
                    "jsonrpc": "2.0",
                    "method": "apiinfo.version",
                    "params": {},
                    "id": 1
                },
                timeout=10
            )
            
            if response.status_code == 200 and 'result' in response.json():
                return {
                    'status': 'ok',
                    'detail': f"API responsive, version: {response.json()['result']}"
                }
            else:
                return {
                    'status': 'warning',
                    'detail': f"API error: {response.status_code}"
                }
        except Exception as e:
            return {'status': 'critical', 'detail': str(e)}
    
    def _check_database(self, node):
        """データベース接続チェック"""
        try:
            result = subprocess.run([
                'ssh', node['host'],
                'mysql -u zabbix -ppassword zabbix -e "SELECT 1" 2>/dev/null'
            ], capture_output=True, timeout=10)
            
            return {
                'status': 'ok' if result.returncode == 0 else 'critical',
                'detail': 'DB connected' if result.returncode == 0 else 'DB connection failed'
            }
        except Exception as e:
            return {'status': 'error', 'detail': str(e)}
    
    def _check_resources(self, node):
        """リソース使用率チェック"""
        try:
            # CPU使用率
            cpu_result = subprocess.run([
                'ssh', node['host'],
                "top -bn1 | grep 'Cpu(s)' | awk '{print $2}' | cut -d'%' -f1"
            ], capture_output=True, text=True, timeout=10)
            
            # メモリ使用率
            mem_result = subprocess.run([
                'ssh', node['host'],
                "free | grep Mem | awk '{print ($3/$2) * 100.0}'"
            ], capture_output=True, text=True, timeout=10)
            
            cpu_usage = float(cpu_result.stdout.strip())
            mem_usage = float(mem_result.stdout.strip())
            
            status = 'ok'
            if cpu_usage > 90 or mem_usage > 90:
                status = 'critical'
            elif cpu_usage > 70 or mem_usage > 70:
                status = 'warning'
            
            return {
                'status': status,
                'detail': f"CPU: {cpu_usage:.1f}%, Memory: {mem_usage:.1f}%",
                'cpu_usage': cpu_usage,
                'memory_usage': mem_usage
            }
        except Exception as e:
            return {'status': 'error', 'detail': str(e)}
    
    def run_monitoring(self):
        """継続的監視の実行"""
        while True:
            cluster_status = {
                'timestamp': datetime.now().isoformat(),
                'nodes': [],
                'cluster_status': 'unknown'
            }
            
            for node in self.nodes:
                node_status = self.check_node_health(node)
                cluster_status['nodes'].append(node_status)
            
            # クラスタ全体ステータス判定
            node_statuses = [node['status'] for node in cluster_status['nodes']]
            
            if all(status == 'healthy' for status in node_statuses):
                cluster_status['cluster_status'] = 'healthy'
            elif any(status == 'critical' for status in node_statuses):
                cluster_status['cluster_status'] = 'degraded'
            else:
                cluster_status['cluster_status'] = 'warning'
            
            # 結果の出力
            print(json.dumps(cluster_status, indent=2))
            
            # アラート送信（必要に応じて）
            if cluster_status['cluster_status'] != 'healthy':
                self._send_alert(cluster_status)
            
            time.sleep(self.check_interval)
    
    def _send_alert(self, cluster_status):
        """アラート送信"""
        # Slack、メール等への通知実装
        pass

# 設定例
nodes = [
    {'name': 'zabbix-node1', 'host': '192.168.1.10'},
    {'name': 'zabbix-node2', 'host': '192.168.1.11'},
    {'name': 'zabbix-node3', 'host': '192.168.1.12'}
]

# 監視開始
monitor = ZabbixClusterMonitor(nodes, check_interval=60)
monitor.run_monitoring()