Leistungsoptimierung

SLAED CMS wurde mit dem Fokus auf hohe Leistung und effiziente Ressourcennutzung entwickelt. Um jedoch maximale Seitengeschwindigkeit zu erreichen, müssen Sie das System und die Serverumgebung ordnungsgemäß konfigurieren.

Inhaltsverzeichnis

Leistungsanalyse
PHP-Optimierung
Datenbank-Optimierung
Caching
Webserver-Optimierung
Bildoptimierung
CDN-Integration
Lazy Loading
Leistungsüberwachung
Skalierung
Optimierungsempfehlungen

Leistungsanalyse

Eingebaute Werkzeuge

SLAED CMS bietet eingebaute Werkzeuge für die Leistungsanalyse:

Systeminformationen - systeminfo.php - Systemeigenschaften, PHP/MySQL-Versionen, Ressourcennutzung
Kompatibilitätsprüfung - check_compat.php - Analyse der Systemanforderungen
Datei-Schreibtest - test_write.php - Dateiberechtigungen und Schreibgeschwindigkeitstest

Externe Werkzeuge

Für eine detailliertere Analyse können Sie folgende Werkzeuge verwenden:

Google PageSpeed Insights - Webseiten-Leistungsanalyse
GTmetrix - Umfassende Geschwindigkeitsanalyse
Pingdom Tools - Test der Seitenladezeit
WebPageTest - Detaillierte Leistungsanalyse

PHP-Optimierung

php.ini-Einstellungen

Für optimale SLAED CMS-Leistung verwenden Sie die folgende PHP-Konfiguration:

; Speicher
memory_limit = 256M

; Ausführungszeit
max_execution_time = 300
max_input_time = 300

; Datei-Uploads
upload_max_filesize = 32M
post_max_size = 32M
max_file_uploads = 20

; OPcache (wesentlich für die Leistung)
opcache.enable = 1
opcache.memory_consumption = 128
opcache.max_accelerated_files = 4000
opcache.revalidate_freq = 60
opcache.save_comments = 0
opcache.fast_shutdown = 1

; Sitzungen
session.gc_maxlifetime = 86400
session.cookie_lifetime = 0
session.cookie_secure = 1
session.cookie_httponly = 1
session.cookie_samesite = "Strict"

; Sicherheit
expose_php = Off
display_errors = Off
log_errors = On

PHP-Erweiterungen

Erforderliche Erweiterungen für die Leistung:

OPcache - PHP-Bytecode-Caching
mysqli - Optimierter MySQL-Zugriff
gd - Bildverarbeitung
zip - Archivverwaltung

Empfohlene Erweiterungen:

APCu - In-Memory-Benutzer-Cache
Redis - Verteilter Cache
Memcached - Hochleistungs-Cache

Datenbank-Optimierung

MySQL/MariaDB-Einstellungen

Empfohlene Einstellungen für my.cnf:

[mysqld]
# Puffer
innodb_buffer_pool_size = 256M
innodb_log_buffer_size = 16M
key_buffer_size = 64M

# Protokolle
innodb_log_file_size = 64M
innodb_flush_log_at_trx_commit = 2

# Abfrage-Cache
query_cache_type = 1
query_cache_size = 32M
query_cache_limit = 2M

# Verbindungen
max_connections = 100
max_connect_errors = 10

# Optimierung
skip-name-resolve
table_open_cache = 2000
table_definition_cache = 2000

Tabellen-Optimierung

Regelmäßige Tabellen-Optimierung:

-- Optimieren aller SLAED CMS Tabellen
OPTIMIZE TABLE sl_users, sl_modules, sl_config, sl_blocks, sl_categories;

Caching

Eingebautes SLAED CMS Caching

SLAED CMS bietet ein mehrstufiges Caching-System:

Seiten-Caching - Vollständiges HTML-Seiten-Caching mit konfigurierbarer Lebensdauer
CSS/JavaScript-Caching - Dateizusammenführung und Minimierung
Block-Caching - Individuelles Block-Caching mit separaten Lebensdauern

Cache-Konfiguration

In config/config_core.php:

$conf = array(
    // Block-Caching
    'cache_b' => '1',           // Block-Caching aktivieren
    'cache_d' => '7',           // Cache-Tage
    'cache_t' => '3600',        // Cache-Lebensdauer (Sekunden)
    
    // CSS/JS-Caching
    'cache_css' => '1',         // CSS-Caching
    'cache_script' => '1',      // JavaScript-Caching
    
    // Komprimierung
    'css_c' => '1',             // CSS-Komprimierung
    'script_c' => '1',          // JavaScript-Komprimierung
    'html_compress' => '1',     // HTML-Komprimierung
);

Externe Caching-Systeme

Redis

// Redis-Verbindung
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

// Caching-Funktionen
function cache_get_redis($key) {
    global $redis;
    return $redis->get($key);
}

function cache_set_redis($key, $data, $ttl = 3600) {
    global $redis;
    return $redis->setex($key, $ttl, $data);
}

Memcached

// Memcached-Verbindung
$memcached = new Memcached();
$memcached->addServer('localhost', 11211);

// Caching-Funktionen
function cache_get_memcached($key) {
    global $memcached;
    return $memcached->get($key);
}

function cache_set_memcached($key, $data, $ttl = 3600) {
    global $memcached;
    return $memcached->set($key, $data, $ttl);
}

Webserver-Optimierung

Apache

Optimieren Sie .htaccess:

# Statische Datei-Caching
<IfModule mod_expires.c>
    ExpiresActive On
    ExpiresByType text/css "access plus 1 month"
    ExpiresByType application/javascript "access plus 1 month"
    ExpiresByType image/png "access plus 1 month"
    ExpiresByType image/jpg "access plus 1 month"
    ExpiresByType image/jpeg "access plus 1 month"
    ExpiresByType image/gif "access plus 1 month"
    ExpiresByType image/svg+xml "access plus 1 month"
</IfModule>

# Komprimierung
<IfModule mod_deflate.c>
    AddOutputFilterByType DEFLATE text/plain
    AddOutputFilterByType DEFLATE text/html
    AddOutputFilterByType DEFLATE text/xml
    AddOutputFilterByType DEFLATE text/css
    AddOutputFilterByType DEFLATE application/xml
    AddOutputFilterByType DEFLATE application/xhtml+xml
    AddOutputFilterByType DEFLATE application/rss+xml
    AddOutputFilterByType DEFLATE application/javascript
    AddOutputFilterByType DEFLATE application/x-javascript
</IfModule>

# ETags
<IfModule mod_headers.c>
    Header unset ETag
    FileETag None
</IfModule>

Nginx

Optimieren Sie die Nginx-Konfiguration:

server {
    # Statische Datei-Caching
    location ~* \.(css|js|png|jpg|jpeg|gif|ico|svg)$ {
        expires 1M;
        add_header Cache-Control "public, immutable";
        add_header Vary "Accept-Encoding";
    }
    
    # Komprimierung
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types
        text/plain
        text/css
        text/xml
        text/javascript
        application/javascript
        application/xml+rss
        application/json;
}

Bildoptimierung

Bildformate

Empfohlene Formate:

WebP - Modernes Format mit besserer Komprimierung
AVIF - Next-Generation-Bildformate
JPEG - Für Fotos
PNG - Für Bilder mit Transparenz

Automatische Optimierung

SLAED CMS unterstützt automatische Bildoptimierung:

// Bildoptimierung beim Upload
function optimize_image($source, $destination, $quality = 85) {
    $info = getimagesize($source);
    
    switch ($info['mime']) {
        case 'image/jpeg':
            $image = imagecreatefromjpeg($source);
            imagejpeg($image, $destination, $quality);
            break;
        case 'image/png':
            $image = imagecreatefrompng($source);
            imagepng($image, $destination, floor($quality/10)-1);
            break;
        case 'image/webp':
            $image = imagecreatefromwebp($source);
            imagewebp($image, $destination, $quality);
            break;
    }
    
    imagedestroy($image);
}

CDN (Content Delivery Network)

CDN-Integration

Um CDN zu verwenden, konfigurieren Sie diese Parameter:

Statische Dateien

// In der Konfiguration
$conf['cdn_url'] = 'https://cdn.yoursite.com';

Ressourcenverbindung

<link rel="stylesheet" href="https://cdn.yoursite.com/templates/default/theme.css">
<script src="https://cdn.yoursite.com/plugins/jquery/jquery.min.js"></script>

Lazy Loading

Lazy Loading für Bilder

Implementierung von Lazy Loading:

<!-- Bilder mit Lazy Loading -->
<img data-src="image.jpg" alt="Beschreibung" class="lazy" loading="lazy">

// JavaScript für Lazy Loading
document.addEventListener("DOMContentLoaded", function() {
    const lazyImages = [].slice.call(document.querySelectorAll("img.lazy"));
    
    if ("IntersectionObserver" in window) {
        let lazyImageObserver = new IntersectionObserver(function(entries, observer) {
            entries.forEach(function(entry) {
                if (entry.isIntersecting) {
                    let lazyImage = entry.target;
                    lazyImage.src = lazyImage.dataset.src;
                    lazyImage.classList.remove("lazy");
                    lazyImageObserver.unobserve(lazyImage);
                }
            });
        });
        
        lazyImages.forEach(function(lazyImage) {
            lazyImageObserver.observe(lazyImage);
        });
    }
});

Leistungsüberwachung

Leistungsprotokollierung

Aktivieren Sie die Ausführungszeitprotokollierung:

// In der Konfiguration
$conf['log_performance'] = 1;
$conf['performance_threshold'] = 1000; // ms

// Protokollierung langsamer Abfragen
function log_slow_query($query, $time) {
    global $conf;
    if ($time > $conf['performance_threshold']) {
        error_log("Langsame Abfrage: {$query} ({$time}ms)", 3, LOGS_DIR.'/performance.log');
    }
}

Warnmeldungen

Konfigurieren Sie Benachrichtigungen bei Leistungsproblemen:

// Warnmeldungen senden
function send_performance_alert($issue, $details) {
    $subject = "Leistungswarnung: {$issue}";
    $message = "Leistungsproblem erkannt:\n\n{$details}";
    mail(ADMIN_EMAIL, $subject, $message);
}

Skalierung

Horizontale Skalierung

Für Websites mit hohem Traffic:

Lastverteilung

upstream slaed_backend {
    server 192.168.1.10:8080;
    server 192.168.1.11:8080;
    server 192.168.1.12:8080;
}

Datenbank-Aufteilung - Master-Slave-Replikation, Tabellen-Sharding

Vertikale Skalierung

Erhöhen Sie die Serverressourcen:

Leistungsstärkerer Prozessor
Mehr RAM
SSD-Speicher
Dedizierter Server

Optimierungsempfehlungen

Checkliste

Aktivieren und konfigurieren Sie OPcache
Optimieren Sie die PHP-Einstellungen
Konfigurieren Sie das MySQL-Caching
Aktivieren Sie das SLAED CMS-Caching
Optimieren Sie Bilder
Verwenden Sie CDN für statische Dateien
Aktivieren Sie Gzip-Komprimierung
Konfigurieren Sie das Browser-Caching
Implementieren Sie Lazy Loading
Führen Sie Lasttests durch

Regelmäßige Wartung

Wöchentlich

Optimierung von Datenbanktabellen
Protokollbereinigung
Cache-Überprüfung

Monatlich

Leistungsanalyse
Updates von PHP und MySQL
Sicherung

Quartalsweise

Code-Audit
Sicherheitsprüfung
Updates von Erweiterungen

Durch die Einhaltung dieser Empfehlungen können Sie maximale Leistung für Ihre SLAED CMS-Website erreichen und ein hervorragendes Benutzererlebnis gewährleisten.