---
title: "Apache als Reverse-Proxy einrichten: Schritt für Schritt"
description: "Apache als Reverse-Proxy mit mod_proxy, ProxyPass und ProxyPassReverse einrichten: Module, ein ganzer VirtualHost, HTTPS, WebSocket, Timeouts und Fehler."
url: https://proxynet.io/de/blog/apache-reverse-proxy
date: 2026-11-19
author: "Acar Diveroli"
category: "Anleitungen"
lang: de
---

# Apache als Reverse-Proxy einrichten: Schritt für Schritt

Ihre neue App läuft auf dem Server unter `127.0.0.1:3000` einwandfrei, und Apache beantwortet für die Firmenwebsite bereits die Ports 80 und 443. Unter `app.example.com` soll die App erreichbar sein, mit dem Zertifikat, das Apache ohnehin verwaltet. Sie ergänzen eine `ProxyPass`-Zeile, öffnen die Seite, klicken auf „Anmelden“, und der Browser springt zu `http://127.0.0.1:3000/login`, einer Adresse, die nur auf dem Server selbst funktioniert. Dieser halb funktionierende Zustand ist das häufigste erste Ergebnis eines Apache-Reverse-Proxys.

Diese Anleitung baut die Einrichtung der Reihe nach auf: Module, ein minimaler VirtualHost, Weiterleitungen und Hostnamen, weitergereichte Header, HTTPS, WebSocket, Timeouts, Load Balancing (Lastverteilung), Tests und die Fehlermeldungen, denen Sie begegnen werden. Die Direktiven stammen aus der Dokumentation des Apache HTTP Server 2.4; das Verhalten des Backends haben wir mit einer Node-App aus zehn Zeilen auf 127.0.0.1 getestet.

> **Hinweis: Kurzantwort**
>
> Laden Sie `mod_proxy` und `mod_proxy_http` (unter Debian und Ubuntu: `sudo a2enmod proxy proxy_http headers`), fügen Sie im VirtualHost der Website `ProxyPass "/" "http://127.0.0.1:3000/"` und `ProxyPassReverse "/" "http://127.0.0.1:3000/"` ein und laden Sie Apache neu, sobald `apachectl configtest` fehlerfrei durchläuft. Lassen Sie `ProxyRequests Off` stehen: Ein Reverse-Proxy braucht die Option nicht. Für HTTPS terminieren Sie TLS in einem VirtualHost auf Port 443 mit `SSLEngine on` und senden `X-Forwarded-Proto` per `RequestHeader`. WebSocket braucht ab Apache 2.4.47 `upgrade=websocket` in der `ProxyPass`-Zeile, in älteren Versionen `mod_proxy_wstunnel`.

## Was macht ein Apache-Reverse-Proxy?

Ein Apache-Reverse-Proxy nimmt die Anfragen für Ihre Website an, reicht sie an einen Anwendungsserver dahinter weiter und gibt dessen Antwort zurück, als hätte Apache sie selbst erzeugt. Der Besucher spricht nur mit Apache; die App auf `127.0.0.1` oder in einem privaten Netz bleibt von außen unerreichbar. Den Unterschied zum Proxy, den ein Client für sich selbst einrichtet, erklärt [Forward-Proxy und Reverse-Proxy: Was ist der Unterschied?](/de/blog/forward-vs-reverse-proxy).

So läuft eine einzelne Anfrage ab:

1. **Apache wählt den VirtualHost,** dessen `ServerName` zum `Host`-Header passt, den der Browser gesendet hat.
2. **Apache prüft die `ProxyPass`-Regeln der Reihe nach;** der erste passende Pfad gewinnt.
3. **`mod_proxy_http` öffnet eine Verbindung zum Backend** und leitet die Anfrage weiter; dabei ergänzt es `X-Forwarded-For`, `X-Forwarded-Host` und `X-Forwarded-Server`.
4. **Das Backend antwortet.** Ist die Antwort eine Weiterleitung, schreibt `ProxyPassReverse` die Backend-Adresse im `Location`-Header auf die öffentliche Adresse um.
5. **Apache schickt die Antwort an den Besucher,** mit dem eigenen TLS-Zertifikat, wenn der VirtualHost HTTPS nutzt.

## Welche Apache-Module brauchen Sie?

Sie brauchen `mod_proxy`, das die Proxy-Grundfunktionen liefert, und dazu ein Protokollmodul für die Art von Backend, mit der Apache spricht. Die [Dokumentation zu mod_proxy](https://httpd.apache.org/docs/2.4/mod/mod_proxy.html) führt sie alle auf; die Module einer typischen Einrichtung stehen unten.

| Modul | Aufgabe | Nötig für |
|---|---|---|
| `mod_proxy` | Proxy-Grundfunktionen | Jede Einrichtung |
| `mod_proxy_http` | Spricht HTTP mit dem Backend | Apps in Node, Python, Java, Go |
| `mod_headers` | Direktive `RequestHeader` | `X-Forwarded-Proto` |
| `mod_ssl` | TLS für die Website | HTTPS |
| `mod_proxy_balancer` | Backend-Pools | Load Balancing |
| `mod_lbmethod_byrequests` | Eine Verteilungsmethode | Load Balancing |
| `mod_proxy_wstunnel` | WebSocket-Tunnel | Apache vor 2.4.47 |
| `mod_proxy_fcgi` | FastCGI-Backends | PHP-FPM |

**Debian und Ubuntu** legen Module in `/etc/apache2/mods-available` ab und schalten sie mit `a2enmod` ein, das Links in `mods-enabled` anlegt. Die [Anleitung von Ubuntu Server zu Apache-Modulen](https://ubuntu.com/server/docs/how-to/web-services/use-apache2-modules/) nutzt dieselben Befehle:

```bash
sudo a2enmod proxy proxy_http headers ssl
sudo systemctl restart apache2
```

**Systeme der RHEL-Familie** laden Module über `LoadModule`-Zeilen in `/etc/httpd/conf.modules.d/`. Im Paket von CentOS Stream 9 lädt `00-proxy.conf` bereits `mod_proxy`, `mod_proxy_http`, `mod_proxy_balancer`, die Verteilungsmethoden und `mod_proxy_wstunnel`, während `mod_ssl` ein eigenes Paket ist (`sudo dnf install mod_ssl`). Fehlt ein Modul, sieht die Zeile so aus:

```apache
LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_http_module modules/mod_proxy_http.so
```

Welche Module geladen sind, zeigt `apachectl -M | grep -i proxy`. Unter Windows stehen dieselben `LoadModule`-Zeilen in `conf\httpd.conf`.

## Wie schreiben Sie eine minimale ProxyPass-Konfiguration?

Setzen Sie eine `ProxyPass`-Zeile und eine passende `ProxyPassReverse`-Zeile in den VirtualHost, der für den öffentlichen Namen antwortet. Das ist die kleinste sinnvolle Einrichtung für die App aus der Einleitung:

```apache
<VirtualHost *:80>
    ServerName app.example.com

    ProxyRequests Off
    ProxyPreserveHost On

    # liefert Apache selbst aus, nicht die App
    ProxyPass "/.well-known/acme-challenge/" "!"

    ProxyPass        "/" "http://127.0.0.1:3000/"
    ProxyPassReverse "/" "http://127.0.0.1:3000/"

    ErrorLog  ${APACHE_LOG_DIR}/app-error.log
    CustomLog ${APACHE_LOG_DIR}/app-access.log combined
</VirtualHost>
```

`${APACHE_LOG_DIR}` ist unter Debian und Ubuntu definiert; auf Systemen der RHEL-Familie schreiben Sie stattdessen `logs/app-error.log`. Speichern Sie die Datei als `/etc/apache2/sites-available/app.conf` und aktivieren Sie sie mit `sudo a2ensite app`, oder legen Sie sie unter `/etc/httpd/conf.d/app.conf` ab.

Drei Regeln entscheiden, ob die Zeilen wie gewünscht arbeiten:

- **Schrägstriche müssen übereinstimmen.** Endet das erste Argument auf `/`, muss auch das zweite so enden, und umgekehrt. Ein Unterschied erzeugt Backend-URLs mit fehlendem oder doppeltem Schrägstrich, was sich meist als 404 der App zeigt.
- **Die Reihenfolge zählt.** Apache prüft `ProxyPass`-Regeln in der Reihenfolge, in der sie stehen, und nimmt den ersten Treffer; setzen Sie längere Pfade deshalb nach oben: `/api/` vor `/`.
- **Ausnahmen kommen zuerst.** Eine `!`-Regel hält einen Pfad aus dem Proxy heraus, hier den Ordner für die Zertifikatsvalidierung, und sie wirkt nur oberhalb der allgemeinen Regel.

Unter einem Unterpfad schickt `ProxyPass "/app/" "http://127.0.0.1:3000/"` die Adresse `/app/orders` als `/orders` an das Backend; die App muss dann Links bauen, die mit `/app/` beginnen, meist über eine Einstellung wie „base path“.

## Was ändern ProxyPassReverse und ProxyPreserveHost?

`ProxyPassReverse` repariert Weiterleitungen, und `ProxyPreserveHost` bestimmt, welchen Hostnamen das Backend sieht. Beides ist wichtig, weil Anwendungen absolute URLs aus dem `Host`-Header der Anfrage bauen, die bei ihnen ankommt.

Unsere Test-App auf 127.0.0.1:3901 tat genau das. Auf eine Anfrage nach `/admin` mit ihrer eigenen Adresse im `Host`-Header antwortete sie mit `302` und `Location: http://127.0.0.1:3901/login`; dieselbe Anfrage mit `Host: www.example.com` ergab `Location: http://www.example.com/login`. Standardmäßig sendet Apache den Host aus dem `ProxyPass`-Ziel, also den ersten Fall: den kaputten Anmeldelink aus der Einleitung.

`ProxyPassReverse` behebt das, indem es die Header `Location`, `Content-Location` und `URI` von Weiterleitungen umschreibt: Ein Wert, der mit der Backend-URL beginnt, wird wieder zu Ihrer öffentlichen Adresse. Links in HTML oder JavaScript bleiben unberührt. Für Cookies schreiben `ProxyPassReverseCookieDomain` und `ProxyPassReverseCookiePath` Domain und Pfad in `Set-Cookie` um.

`ProxyPreserveHost On` reicht den ursprünglichen `Host`-Header des Besuchers an das Backend weiter, sodass die App von Anfang an korrekte URLs baut. Laut Apache-Dokumentation bleibt die Option im Normalfall ausgeschaltet, weil ein Backend, das nur seinen internen Namen kennt, den öffentlichen ablehnen kann. Schalten Sie sie ein, wenn die App den Hostnamen prüft, absolute Links erzeugt oder mehrere Domains bedient.

## Wie erfährt das Backend IP-Adresse und Protokoll des Besuchers?

Über Anfrage-Header, die Apache auf dem Weg hinein ergänzt. Im Reverse-Proxy-Betrieb fügt `mod_proxy_http` drei davon selbst hinzu, gesteuert über `ProxyAddHeaders`, das standardmäßig eingeschaltet ist:

- **`X-Forwarded-For`**: die IP-Adresse des Besuchers.
- **`X-Forwarded-Host`**: der `Host`-Header, den der Besucher gesendet hat.
- **`X-Forwarded-Server`**: der eigene Hostname des Proxys.

`X-Forwarded-Proto`, das der App sagt, ob der Besucher HTTPS genutzt hat, kommt nicht automatisch hinzu. Setzen Sie es mit `mod_headers` im HTTPS-VirtualHost: `RequestHeader set X-Forwarded-Proto "https"`. Die Aktion `set` ersetzt jeden Wert, den der Client mitgeschickt hat.

Behandeln Sie diese Header als Hinweise, nicht als Beweis. Trägt eine Anfrage bereits `X-Forwarded-For`, hängt Apache seinen Eintrag an, und das Backend erhält eine kommagetrennte Liste. Unsere Test-App bekam `198.51.100.9, 203.0.113.7` genau so, wie wir die Werte mit curl gesendet hatten, und konnte nicht erkennen, welchen Eintrag ein Proxy hinzugefügt hatte. Binden Sie die App an `127.0.0.1`, damit nur Apache sie erreicht, und lassen Sie das Framework weitergereichten Headern nur von diesem einen Proxy vertrauen.

## Wie ergänzen Sie HTTPS beim Apache-Reverse-Proxy?

Terminieren Sie TLS in Apache: Ein VirtualHost auf Port 443 hält das Zertifikat, entschlüsselt die Anfrage und reicht einfaches HTTP an die App auf dem lokalen Rechner weiter. Port 80 leitet dann nur noch um:

```apache
<VirtualHost *:80>
    ServerName app.example.com
    Redirect permanent "/" "https://app.example.com/"
</VirtualHost>

<VirtualHost *:443>
    ServerName app.example.com

    SSLEngine on
    SSLCertificateFile    /etc/ssl/app.example.com/fullchain.pem
    SSLCertificateKeyFile /etc/ssl/app.example.com/privkey.pem

    ProxyRequests Off
    ProxyPreserveHost On
    RequestHeader set X-Forwarded-Proto "https"

    ProxyPass        "/" "http://127.0.0.1:3000/"
    ProxyPassReverse "/" "http://127.0.0.1:3000/"
</VirtualHost>
```

Die Zertifikatspfade sind Platzhalter; verwenden Sie die Dateien, die Ihr Zertifikatswerkzeug schreibt. Seit Apache 2.4.8 kann `SSLCertificateFile` nach dem Serverzertifikat auch die Zwischenzertifikate enthalten, was das ältere `SSLCertificateChainFile` ersetzt. Prüft Ihr Zertifikatswerkzeug die Domain über einfaches HTTP, kontrollieren Sie, ob das nach dem Einbau der Weiterleitung noch funktioniert; viele Werkzeuge ergänzen eine eigene Regel für Port 80.

Spricht das Backend selbst HTTPS, schreiben Sie `https://` in `ProxyPass` und ergänzen `SSLProxyEngine on`. Apache prüft dann standardmäßig den Namen im Zertifikat des Backends (`SSLProxyCheckPeerName`), und eine Abweichung endet in einem 502. Weil `mod_proxy_http` den Pfad lesen muss, entschlüsselt Apache die Anfrage immer; den verschlüsselten Datenstrom des Besuchers reicht es nicht unverändert durch.

## Wie leiten Sie WebSocket-Verbindungen weiter?

Ab Apache 2.4.47 ergänzen Sie `upgrade=websocket` in der `ProxyPass`-Zeile, die den WebSocket-Pfad bedient. `mod_proxy_http` leitet dann die `Upgrade`-Anfrage des Browsers weiter und macht die Verbindung nur dann zum Tunnel, wenn das Backend mit `101 Switching Protocols` antwortet:

```apache
ProxyPass        "/socket/" "http://127.0.0.1:3000/socket/" upgrade=websocket
ProxyPassReverse "/socket/" "http://127.0.0.1:3000/socket/"
ProxyPass        "/" "http://127.0.0.1:3000/"
ProxyPassReverse "/" "http://127.0.0.1:3000/"
```

Ihre Version zeigt `apachectl -v`. Unter 2.4.46 und älter laden Sie `mod_proxy_wstunnel` und lassen den WebSocket-Pfad stattdessen auf eine `ws://`-URL zeigen: `ProxyPass "/socket/" "ws://127.0.0.1:3000/socket/"`. In beiden Fällen steht die WebSocket-Regel über der allgemeinen `/`-Regel. Der Browser kann weiterhin `wss://` nutzen, während Apache mit der lokalen App einfaches `ws` spricht, denn TLS endet bei Apache. Genau das ist gemeint, wenn bei Apache von „WebSocket über SSL“ die Rede ist.

## Wie stellen Sie Timeouts für einen Reverse-Proxy ein?

Apache wartet bis zu `ProxyTimeout` darauf, dass das Backend Daten sendet, und `ProxyTimeout` übernimmt standardmäßig das serverweite `Timeout` von 60 Sekunden. Eine Berichtsseite, deren Backend zwei Minuten rechnet, bevor das erste Byte kommt, scheitert deshalb nach einer Minute, wenn Sie keinen der beiden Werte erhöhen:

```apache
ProxyTimeout 180

ProxyPass "/reports/" "http://127.0.0.1:3000/reports/" timeout=300 connectiontimeout=5
ProxyPass "/"         "http://127.0.0.1:3000/"
```

`ProxyTimeout` gilt für den ganzen VirtualHost. Der Parameter `timeout=` überschreibt ihn für ein einzelnes Ziel, und `connectiontimeout=` begrenzt das Warten auf die Verbindung selbst, sodass ein ausgefallenes Backend nach Sekunden scheitert. `retry=` legt fest, wie lange ein ausgefallenes Backend ungenutzt bleibt (standardmäßig 60 Sekunden). Erhöhen Sie Timeouts nur, wo es nötig ist, denn jede wartende Anfrage belegt einen Apache-Worker.

## Wie verteilen Sie Last mit mod_proxy_balancer?

Definieren Sie eine `balancer://`-Gruppe mit einem `BalancerMember` pro Backend und lassen Sie `ProxyPass` auf die Gruppe zeigen. Neben `mod_proxy` und `mod_proxy_http` braucht das `mod_proxy_balancer` und mindestens ein Methodenmodul wie `mod_lbmethod_byrequests`:

```apache
<Proxy "balancer://appcluster">
    BalancerMember "http://10.0.0.11:3000" route=a
    BalancerMember "http://10.0.0.12:3000" route=b
    BalancerMember "http://10.0.0.13:3000" status=+H
    ProxySet lbmethod=byrequests stickysession=ROUTEID
</Proxy>

Header add Set-Cookie "ROUTEID=.%{BALANCER_WORKER_ROUTE}e; path=/" env=BALANCER_ROUTE_CHANGED

ProxyPass        "/" "balancer://appcluster/"
ProxyPassReverse "/" "balancer://appcluster/"
```

`byrequests` verteilt die Anfragen gleichmäßig, `bytraffic` verteilt nach Bytes, und `bybusyness` wählt das am wenigsten ausgelastete Mitglied. `status=+H` macht den dritten Server zur Reserve (Hot Standby), die nur Verkehr übernimmt, wenn die anderen ausfallen. Die `route`-Werte und das Cookie `ROUTEID` (gesetzt mit `mod_headers`) halten jeden Besucher bei einem Mitglied, was zählt, wenn eine App Sitzungen im Arbeitsspeicher hält.

Die [Apache-Anleitung zum Reverse-Proxy](https://httpd.apache.org/docs/2.4/howto/reverse_proxy.html) behandelt außerdem Health Checks mit `mod_proxy_hcheck` und die Statusseite `balancer-manager`, die auf vertrauenswürdige Adressen beschränkt sein muss, zum Beispiel mit `Require host localhost`.

Wie sich die Methoden unterscheiden, erklärt [Was ist Load Balancing? Algorithmen und Arten](/de/blog/what-is-load-balancing).

## Warum muss ProxyRequests auf Off bleiben?

Weil `ProxyRequests On` Apache zu einem Forward-Proxy macht, der für jeden Anfragenden beliebige URLs abruft, und `ProxyPass` ohne diese Option funktioniert; `Off` ist außerdem der Standard. Ein offener Forward-Proxy auf einem öffentlichen Server wird von Fremden gefunden und für Spam und Angriffe genutzt. Diese Anfragen verlassen Ihren Server mit dessen IP-Adresse, die dann auf Sperrlisten landet und in Missbrauchsmeldungen an Ihren Hoster auftaucht. Schreiben Sie `ProxyRequests Off` ausdrücklich hin, damit eine aus einem alten Tutorial kopierte Zeile die Option nicht unbemerkt einschaltet; ein Forward-Proxy für Ihre eigenen Rechner braucht einen `<Proxy "*">`-Block mit `Require ip`.

## Wie testen Sie die Konfiguration?

Testen Sie in drei Schritten: die Syntax, das Backend allein und den Weg über Apache. Führen Sie Folgendes auf dem Server aus:

```bash
sudo apachectl configtest          # Syntaxpruefung, nennt Datei und Zeile eines Fehlers
sudo apachectl -S                  # welcher VirtualHost fuer welchen Namen und Port antwortet
curl -I http://127.0.0.1:3000/     # das Backend allein
sudo systemctl reload apache2      # RHEL-Familie: sudo systemctl reload httpd
curl -I https://app.example.com/   # der ganze Weg ueber Apache
```

`curl -I` gibt nur die Statuszeile und die Header aus. Antwortet das Backend direkt, aber nicht über Apache, liegt das Problem in den Proxy-Zeilen; antwortet keines von beiden, starten Sie zuerst die App. Bei einer Weiterleitung muss der `Location`-Header den öffentlichen Namen zeigen, niemals `127.0.0.1`. Wenn etwas scheitert, lesen Sie das Fehlerprotokoll: `/var/log/apache2/error.log` unter Debian und Ubuntu, `/var/log/httpd/error_log` auf Systemen der RHEL-Familie oder die Datei, die der VirtualHost nennt.

## Ist das dieselbe Art von Proxy, die Proxy-Dienste verkaufen?

Nein. Ein Reverse-Proxy steht vor Ihrem Server und spricht für ihn; die Proxys, die ein Anbieter verkauft, stehen vor Ihrem Client. Ein [HTTPS-Proxy](https://proxynet.io/de/https-proxy) ist ein Forward-Proxy: Ihr Browser, Ihr Skript oder Ihr Server schickt ausgehende Anfragen an ihn, und die Zielseite sieht die IP-Adresse des Proxys.

Beides kann in einem System zusammenkommen, etwa wenn die App hinter Ihrem Apache die API eines Partners aufruft, die nur eine einzige freigegebene Adresse akzeptiert. Ein [Datacenter-Proxy](https://proxynet.io/de/datacenter-proxy) gibt diesem ausgehenden Verkehr eine dedizierte, feste IPv4-Adresse; pro IP verkaufte Produkte kommen standardmäßig mit einer Zielseiten-Beschränkung, prüfen Sie also, ob der Host des Partners über Ihre IPs erreichbar ist.

## Wo Apache-Reverse-Proxys zum Einsatz kommen

Der klassische Fall ist ein Anwendungsserver, der nicht direkt am Internet hängen soll: eine Node-, Python- oder Go-App auf einem lokalen Port oder eine Java-App in Tomcat auf Port 8080, während Apache Zertifikate und Logs übernimmt. Server, auf denen Apache schon für andere Websites läuft, bekommen eine `ProxyPass`-Zeile statt eines zweiten Webservers. Teams nutzen Apache auch, um mehrere Apps unter einer Domain zu bündeln, PHP über PHP-FPM mit `mod_proxy_fcgi` auszuführen und eine ältere App hinter aktuellen TLS-Einstellungen online zu halten.

## Häufige Fehler beim Apache-Reverse-Proxy

Die meisten Probleme hinterlassen eine eindeutige Zeile im Fehlerprotokoll:

- **`Invalid command 'ProxyPass', perhaps misspelled or defined by a module not included in the server configuration`**: `mod_proxy` ist nicht geladen. Aktivieren Sie das Modul und führen Sie `configtest` erneut aus.
- **503 Service Unavailable mit `AH00957: … attempt to connect to 127.0.0.1:3000 … failed` und `AH01114: HTTP: failed to make connection to backend`**: Unter der Backend-Adresse lauscht nichts. Starten Sie die App oder korrigieren Sie den Port. Apache lässt dieses Backend danach für die Dauer von `retry=` (standardmäßig 60 Sekunden) ungenutzt und protokolliert `AH00940 … disabled connection`; der 503 kann die Korrektur also um bis zu eine Minute überdauern.
- **502 Bad Gateway mit `Error reading from remote server`**: Das Backend hat die Verbindung angenommen, sie dann aber geschlossen oder bis über den Timeout hinaus geschwiegen. Prüfen Sie das Log der App, dann die Timeout-Einstellungen. Alle Ursachen dieses Statuscodes sammelt [502 Bad Gateway: Bedeutung und Lösung des Fehlers](/de/blog/502-bad-gateway).
- **502 nach dem Umstellen des Backends auf `https://`**: `SSLProxyEngine` fehlt, oder das Zertifikat des Backends passt nicht zu dessen Namen.
- **Weiterleitungen auf `127.0.0.1` oder den internen Host**: `ProxyPassReverse` fehlt oder seine URL weicht vom `ProxyPass`-Ziel ab, oder die App braucht `ProxyPreserveHost On`.
- **Der Browser meldet zu viele Weiterleitungen**: Die App sieht von Apache nur einfaches HTTP und leitet endlos auf HTTPS um. Senden Sie `X-Forwarded-Proto "https"` und lassen Sie das Framework diesem Header vertrauen.
- **Unerwartete 404 der App**: Die beiden `ProxyPass`-Argumente unterscheiden sich beim abschließenden Schrägstrich, oder die App kennt einen Unterpfad nicht.
- **Die WebSocket-Verbindung scheitert oder schließt sofort**: `upgrade=websocket` fehlt, die WebSocket-Regel steht unter der `/`-Regel, oder der Server läuft mit einer Version vor 2.4.47 ohne `mod_proxy_wstunnel`.

## Entscheidungshilfe

| Bedarf | Empfehlung |
|---|---|
| Eine App unter einer Domain veröffentlichen | `ProxyPass` + `ProxyPassReverse` in ihrem VirtualHost |
| Die App baut absolute Links | `ProxyPreserveHost On` |
| Die App muss von HTTPS wissen | `RequestHeader set X-Forwarded-Proto "https"` |
| HTTPS für Besucher | VirtualHost auf Port 443 mit `SSLEngine on` |
| Das Backend spricht HTTPS | Ziel mit `https://` + `SSLProxyEngine on` |
| WebSocket ab Apache 2.4.47 | `upgrade=websocket` |
| WebSocket mit älterem Apache | `mod_proxy_wstunnel` + `ws://` |
| Langsame Seiten laufen in den Timeout | `timeout=` für diesen Pfad oder `ProxyTimeout` |
| Mehrere App-Server | `balancer://` mit `mod_proxy_balancer` |
| Einen Pfad bei Apache behalten | `ProxyPass "/path/" "!"` über der Hauptregel |

## Häufige Fragen

### Was ist der Unterschied zwischen ProxyPass und ProxyPassReverse?

`ProxyPass` schickt Anfragen für einen Pfad an das Backend; `ProxyPassReverse` schreibt auf dem Rückweg die Backend-Adresse in den Weiterleitungs-Headern um. Verwenden Sie beide mit denselben Argumenten, sonst schicken die Weiterleitungen der App Besucher an eine Adresse, die sie nicht erreichen.

### Brauche ich ProxyRequests On für einen Reverse-Proxy?

Nein. `ProxyRequests` steuert nur den Forward-Proxy-Betrieb, und `ProxyPass` funktioniert bei ausgeschalteter Option, die ohnehin der Standard ist. Wer sie ohne strenge Zugriffsregeln einschaltet, schafft einen offenen Proxy, den jeder nutzen kann.

### Wie betreibe ich mehrere Domains oder Apps hinter einem Apache-Reverse-Proxy?

Geben Sie jeder Domain einen eigenen VirtualHost mit eigenem `ServerName` und eigenen `ProxyPass`-Zeilen, oder teilen Sie eine Domain mit mehreren `ProxyPass`-Regeln nach Pfaden auf, den längsten Pfad zuerst. `apachectl -S` zeigt, welcher VirtualHost für welchen Namen antwortet.

### Wie leite ich WebSocket über SSL mit Apache weiter?

Terminieren Sie TLS wie gewohnt im VirtualHost auf Port 443 und ergänzen Sie `upgrade=websocket` in der `ProxyPass`-Zeile für den Socket-Pfad. Der Browser verbindet sich mit `wss://`, und Apache spricht mit dem lokalen Backend einfaches WebSocket.

### Wie erhöhe ich den Timeout des Apache-Reverse-Proxys?

Setzen Sie `ProxyTimeout` im VirtualHost, oder ergänzen Sie `timeout=` in einer einzelnen `ProxyPass`-Zeile, um nur diesen Pfad zu ändern. Beide Werte sind Sekunden; ohne sie nutzt Apache das serverweite `Timeout` von 60 Sekunden.

### Kann ich einen Apache-Reverse-Proxy unter Windows betreiben?

Ja. Die Direktiven sind dieselben; Sie aktivieren `mod_proxy` und `mod_proxy_http`, indem Sie das `#` vor ihren `LoadModule`-Zeilen in `conf\httpd.conf` entfernen. Das Apache-Projekt selbst veröffentlicht nur Quellcode, der Windows-Build stammt also aus einer Distribution von Drittanbietern.

## Fazit

Ein Apache-Reverse-Proxy braucht `mod_proxy` mit `mod_proxy_http` und einen VirtualHost mit passenden `ProxyPass`- und `ProxyPassReverse`-Zeilen; `ProxyPreserveHost` und `X-Forwarded-Proto` sorgen dafür, dass die App korrekte URLs baut. Terminieren Sie HTTPS auf Port 443, ergänzen Sie `upgrade=websocket` für Sockets, erhöhen Sie `timeout=` nur dort, wo Seiten langsam sind, und nutzen Sie `balancer://` für mehrere Backends. Lassen Sie `ProxyRequests Off` stehen, führen Sie vor jedem Neuladen `apachectl configtest` aus und lesen Sie das Fehlerprotokoll, bevor Sie irgendetwas anderes ändern.
