---
url: 'https://sithis.xyz/tutorials/drupal-cms-fuer-selfmade-men-und-macher/config-und-redis'
title: 'Level 7 - Apache Config und Redis'
author:
  name: 'Joachim Namyslo'
  url: 'https://sithis.xyz/team/joachim'
  sameAs:
    - 'https://www.youtube.com/@jo_de'
    - 'https://github.com/nodedropweb'
    - 'https://www.drupal.org/u/Joachim-Namyslo'
date: '2026-08-29T19:24:42+00:00'
updated: '2026-09-05T10:44:18+00:00'
type: article
summary: 'Apache zeigt jetzt auf den richtigen Ordner, AllowOverride aktiviert saubere URLs, und Redis übernimmt als Kurzzeitgedächtnis die Performance-Arbeit.'
tags:
  - 'Drupal CMS für Selfmade-Men und Macher'
image: 'https://sithis.xyz/sites/default/files/2026-08/a%C3%BCache2-config-und-redis.png'
published: true
og:
  site_name: 'Drupal TV'
  updated_time: '2026-09-05T12:44:18+02:00'
---
# Level 7 - Apache Config und Redis

 

**Serie:** Drupal CMS für Selfmade-Men und Macher

## Key Facts

- DocumentRoot: Moderne Frameworks legen die öffentliche index.php oft in einen Unterordner (z.B. /web oder /public), um den Core-Code zu schützen. Die Apache-Config muss darauf zeigen.
- AllowOverride All: Ohne diese Zeile funktionieren Drupals saubere URLs und Sicherheitsregeln (in der .htaccess) nicht.
- Redis: Ein Key-Value-Store, der Daten im RAM hält. Für High-Performance-Drupal essenziell, um die Datenbank zu entlasten.
- Service Restart: Nach jeder Konfigurationsänderung (Apache) oder Modul-Installation (PHP) müssen die Dienste neu gestartet werden (systemctl restart).
- Redis ist erst nutzbar, wenn du ihn in settings.php als cache.backend.redis einträgst und drush cache:rebuild ausführst – der laufende Server allein bringt keine einzige Millisekunde Geschwindigkeit.
- InstallerKernel-Falle: Seit Drupal 10 heißt die Installations-Check-Funktion in settings.php \\Drupal\\Core\\Installer\\InstallerKernel::installationAttempted() – die alte drupal\_installation\_attempted() existiert nicht mehr und wirft einen Fatal Error auf der ganzen Seite.

Aktueller Status:

- Die Software liegt in /var/www/cms.
- Der Webserver schaut aber immer noch auf /var/www/html.

Wenn du deine Seite jetzt aufrufst, siehst du entweder die alte Standard-Seite oder eine Fehlermeldung. Der Kellner (Apache) steht im falschen Raum. Außerdem haben wir versprochen, dein System auf **Enterprise-Niveau** zu heben. Das heißt: Wir installieren **Redis**.

Redis ist ein In-Memory-Speicher. Stell dir das vor wie das Kurzzeitgedächtnis eines Genies. Drupal legt dort Dinge ab, die es oft braucht (z.B. Menüs oder Konfigurationen). Statt diese jedes Mal mühsam aus der MariaDB-Datenbank zu kramen (was Millisekunden kostet), holt es sie aus dem RAM (was Nanosekunden dauert). Das ist der Unterschied zwischen "schnell" und "sofort".



Schritte

Den Kellner neu einnorden (Apache VHost)

Wir müssen Apache erklären: "Dein neues Zuhause ist /var/www/cms/web." Wichtig: /web. Das ist eine Sicherheitsfunktion von Drupal. Die Systemdateien liegen eine Ebene höher, unerreichbar für Hacker. Nur der öffentliche Teil liegt in /web.

Öffnen wir die Konfiguration:

sudo nano /etc/apache2/sites-available/000-default.conf

Lösche den alten Inhalt (oder pass ihn an) und füge diesen Block ein. Er ist perfekt auf Drupal abgestimmt:

```apache
<VirtualHost *:80>    

# Admin-Email (optional anpassen)    

ServerName meinedomain.de
    ServerAlias www.meinedomain.de
    ServerAdmin webmaster@localhost

# WICHTIG: Der Pfad zum "web"-Ordner    

DocumentRoot /var/www/cms/web    

# Logs für Fehler und Zugriffe    

ErrorLog ${APACHE_LOG_DIR}/error.log    
CustomLog ${APACHE_LOG_DIR}/access.log combined   

 # Hier erlauben wir Drupal, die URLs zu steuern (.htaccess)    

<Directory /var/www/cms/web>        
Options Indexes FollowSymLinks        
AllowOverride All        
Require all granted    
</Directory> 

</VirtualHost>
```

Speichern (STRG+O, Enter) und Beenden (STRG+X).



 



Den Turbo einbauen (Redis Installation)

Jetzt installieren wir den Redis-Server und das passende PHP-Modul, damit unser Koch mit dem Turbo reden kann.

```bash
sudo apt install redis-server php8.5-redis -y
```

Ob Redis läuft, prüfen wir kurz mit dem "Ping"-Befehl:

```bash
redis-cli ping
```

Antwortet er mit PONG? Sehr gut. Der Turbo summt.



 



Das System neu starten

Wir haben die Konfiguration von Apache geändert und ein neues PHP-Modul installiert. Damit das wirksam wird, starten wir die Dienste neu.

```bash
sudo systemctl restart apache2 php8.5-fpm
```



 



Der Browser-Check

Jetzt wird es spannend. Öffne deinen Browser und gib deine **Server-IP** ein.

Statt der langweiligen Apache-Seite solltest du jetzt (hoffentlich!) eine schlichte Seite sehen, die vielleicht etwas von "Installation" murmelt oder zumindest anders aussieht als vorher. Wenn du eine Fehlermeldung siehst, keine Panik – Drupal ist noch nicht installiert, es fehlen noch die Datenbank-Zugangsdaten. Aber wenn sich das *Aussehen* der Fehlermeldung geändert hat (z.B. Drupal-Styles), wissen wir: Der Kellner hat den richtigen Raum gefunden!



 



Der Turbo bekommt ein Gaspedal (Redis mit Drupal verbinden)

Kleiner Realitäts-Check, den viele Tutorials unter den Tisch fallen lassen: apt install redis-server allein bringt exakt nichts. Der Turbo-Motor steht jetzt im Auto, aber niemand hat das Gaspedal angeschlossen. Drupal weiß bis hierhin noch gar nichts von Redis – es würde stur weiter in die MariaDB-Datenbank cachen, wie eh und je.

Diesen Teil verkabelst du, sobald dein Drupal tatsächlich steht (also nach Level 8, der Installation). Wir zeigen ihn dir trotzdem schon jetzt komplett, damit "Config und Redis" auch wirklich hält, was der Titel verspricht.

**1. Das Redis-Modul für Drupal holen** – bei einem Composer-Projekt läuft das immer über Composer, nie über die Drupal-Oberfläche:

```bash
composer require drupal/redis
```

**2. Modul aktivieren:**

```bash
drush pm:enable redis --yes
```

**3. Drupal beibringen, dass es Redis benutzen soll.** Das trägst du in deine settings.php ein, meistens ganz unten, nach den Datenbank-Zugangsdaten:

```php
if (extension_loaded('redis') && !\Drupal\Core\Installer\InstallerKernel::installationAttempted()) {
  $settings['redis.connection']['interface'] = 'PhpRedis';
  $settings['redis.connection']['host'] = '127.0.0.1';
  $settings['redis.connection']['port'] = 6379;
  $settings['cache_prefix'] = 'meineseite';
  $settings['cache']['default'] = 'cache.backend.redis';
  $settings['container_yamls'][] = 'modules/contrib/redis/example.services.yml';
}
```

Stolperfalle, die uns in der Praxis selbst erwischt hat: Viele ältere Redis-Anleitungen prüfen mit drupal\_installation\_attempted(), ob gerade eine Installation läuft. Diese Funktion gibt es in aktuellen Drupal-Versionen (10/11) nicht mehr – sie heißt jetzt \\Drupal\\Core\\Installer\\InstallerKernel::installationAttempted(). Nimmst du die alte Variante, killt das deine komplette Seite mit einem Fatal Error, weil settings.php bei *jedem einzelnen* Request geladen wird. Kein Redis-Problem – reines Copy-Paste-Risiko.

**4. Cache neu aufbauen**, damit die neue Konfiguration greift:

```bash
drush cache:rebuild
```

**5. Gegenprobe:** Landen wirklich Daten im Redis-Speicher, oder redet Drupal nur theoretisch mit ihm?

```bash
redis-cli dbsize
```

Kommt da eine Zahl größer als Null zurück – bei uns waren es auf Anhieb über 2000 Einträge – dann spricht Drupal jetzt wirklich mit dem Turbo. Nicht nur nebenher installiert, sondern tatsächlich angeschlossen.



 



Was haben wir erreicht?

Wir haben die Infrastruktur final verdrahtet:

1. **Apache** weiß jetzt, wo Drupal liegt (DocumentRoot).
2. **AllowOverride All** erlaubt Drupal, schöne URLs (/ueber-uns) zu generieren.
3. **Redis** läuft im Hintergrund und wartet darauf, Daten zu cachen.

Alles ist bereit für den großen Moment. Im nächsten Level wecken wir das Monster. Wir installieren Drupal und verbinden es mit der MariaDB-Datenbank.

Bereit für die Zündung?