Zum Hauptinhalt springen

Benutzerdefinierte Domain (Reverse Proxy)

Die CASABLANCA Booking Engine ist vollständig reverse-proxy-fähig. Du kannst sie problemlos über eine eigene Domain (z. B. booking.yourhotel.com) einbinden – ohne zusätzliche Konfigurationen, Freischaltungen oder Zugänge auf CASABLANCA-Seite.

Warum eine eigene Domain?​


Beim Buchen zählen Vertrauen und ein einheitlicher Markenauftritt. Wenn ein Gast von deiner Website yourhotel.com zu einer langen, komplizierten URL wie bookingengine.casablanca.at/de/b745defa… wechselt, kann das Reibung und Verwirrung verursachen.

Eine eigene Domain (z. B. booking.yourhotel.com) bietet:

  • Einen einheitlichen, professionellen Auftritt: Der Gast hat nie das Gefühl, deine Website verlassen zu haben. Das Branding bleibt vom Stöbern bis zur Zahlung durchgängig.
  • Höhere Konversionsraten: Marketingdaten zeigen, dass Nutzer einen Checkout eher abschließen, wenn die URL in der Adresszeile zu der Marke passt, der sie ursprünglich vertraut haben.

Warum ein Proxy und keine Weiterleitung?​


Eine einfache Domain-Weiterleitung schickt den Gast nur auf die lange URL des Drittanbieters weiter. Damit geht der Zweck einer eigenen Domain verloren.

Damit der Browser während der gesamten Buchung bei booking.yourhotel.com bleibt, brauchst du einen Reverse Proxy. Er ruft die Booking Engine im Hintergrund sicher ab und verbirgt die komplexe URL vor dem Gast.

Da Gäste sensible persönliche Daten und Zahlungsdaten eingeben, muss die Verbindung mit einem SSL-Zertifikat abgesichert sein. Ohne korrektes SSL-Setup blockieren Browser wie Chrome oder Safari die Seite und zeigen eine deutliche „Nicht sicher“-Warnung. Wenn du den Proxy über Cloudflare betreibst, wird das SSL-Zertifikat automatisch erzeugt und verwaltet. So ist die Übertragung durchgängig verschlüsselt.

Umsetzung​


Ein Reverse Proxy leitet Anfragen von der gewünschten Domain an die Booking Engine weiter. Dieser Proxy ist kein Bestandteil des CASABLANCA-Produkts und wird nicht von CASABLANCA bereitgestellt oder betrieben.

Mögliche Implementierungen:

  • Cloudflare Workers
  • Reverse-Proxy-Funktionen in CMS-Systemen (z. B. WordPress, TYPO3)
  • Eigene serverseitige Skripte

Voraussetzung: Die Weiterleitung und das URL-Rewriting müssen korrekt konfiguriert sein, damit alle Funktionen der Booking Engine vollständig verfügbar bleiben.

Beispiel: Proxy über Cloudflare Workers​


Hier ist der Ablauf, um einen transparenten Reverse Proxy für deine CASABLANCA Booking Engine zu erstellen.

Vor dem Start​

Registriere dich für ein kostenloses Cloudflare-Konto, falls du noch keines hast, und füge deine Domain zu Cloudflare hinzu.

Hinweis

Stelle sicher, dass das DNS deiner Domain von Cloudflare verwaltet wird. Bei deiner Domain sollte die orange Wolke 🟠 („Proxied“) aktiviert sein.

Schritt 1: Worker erstellen​

  1. Klicke im Dashboard deines Cloudflare-Kontos in der linken Seitenleiste auf Workers & Pages, um die Übersichtsseite zu öffnen.
  2. Klicke auf Create application und danach auf Get started.

Create application und Get started in Cloudflare

  1. Klicke auf Create Worker.

Create Worker in Cloudflare

Schritt 2: Worker benennen​

  1. Vergib dem Worker einen aussagekräftigen Namen, zum Beispiel booking-proxy.
  2. Klicke auf Deploy.

Mach dir um den Code noch keine Gedanken, du bearbeitest ihn im nächsten Schritt.

Worker benennen und deployen

Dein Worker ist jetzt veröffentlicht.

Schritt 3: Proxy-Code einfügen​

  1. Klicke im nächsten Fenster auf Edit Code.

Worker-Code bearbeiten

  1. Entferne den standardmäßig vorhandenen Hello World-Code und füge stattdessen den unten bereitgestellten Code ein.
  2. Bevor du speicherst, musst du zwei Variablen am Anfang des Skripts anpassen:
    • tenantId – Ersetze den Wert durch deine eindeutige Tenant-ID, die du von uns erhalten hast (rot markiert).
    • spaceName – Ersetze den Wert durch den Namen deines Spaces (blau markiert).
Bitte ausklappen
export default {
async fetch(request) {
const url = new URL(request.url);
const targetDomain = "bookingengine.casablanca.at";

// --- UPDATE THESE VARIABLES ---
const tenantId = "<tenantId>";
const spaceName = "<spaceName>";
// ------------------------------

const hiddenPath = `/${tenantId}/${spaceName}`;

// Capture the original public hostname BEFORE we overwrite url.hostname.
// We need this for rewriting Origin/Referer/Set-Cookie and for X-Forwarded-Host.
const originalHost = url.hostname;

// Capture the locale of the CURRENT request (first path segment) before we
// rewrite the path. We need it in step 7 to rebuild locale-less links.
const localeMatch = url.pathname.match(/^\/([a-zA-Z]{2})(?:\/|$)/);
const currentLocale = localeMatch ? localeMatch[1] : "";

// 1. Rewrite incoming request path (preserves trailing slashes safely)
const langRegex = /^\/([a-zA-Z]{2})(\/|$)(.*)$/;
const match = url.pathname.match(langRegex);
if (match && !url.pathname.includes(tenantId)) {
const lang = match[1];
const slash = match[2];
const rest = match[3];
url.pathname = `/${lang}${hiddenPath}${slash}${rest}`;
} else if (url.pathname === "/") {
// Bare root with no locale: hand the origin the tenant path and let its
// i18n middleware redirect to the locale-prefixed URL. Step 5 then strips
// the tenant path back out of the Location header.
url.pathname = hiddenPath;
}

// 2. Change the hostname to the target provider
url.hostname = targetDomain;

// 3. Create a new request
const proxyRequestInit = {
method: request.method,
headers: request.headers,
redirect: "manual"
};

// Only attach body if it's not a GET/HEAD request
if (request.method !== "GET" && request.method !== "HEAD") {
proxyRequestInit.body = request.body;
}

const proxyRequest = new Request(url.toString(), proxyRequestInit);
proxyRequest.headers.set("Host", targetDomain);

// --- HEADER HANDLING FOR ANALYTICS / GEO / DEVICE TRACKING ---

// Rewrite Origin to target so the origin doesn't see a CORS mismatch,
// but we DON'T delete it (deleting breaks some attribution/anti-fraud logic).
proxyRequest.headers.set("Origin", `https://${targetDomain}`);

// Rewrite Referer to point at the target domain equivalent so referrer-based
// logic on the origin still works. Preserves the path/query for attribution.
const referer = request.headers.get("Referer");
if (referer) {
try {
const refUrl = new URL(referer);
// If the referer was on our public domain, rewrite hostname to target.
// Otherwise (external referer like google.com) pass it through unchanged.
if (refUrl.hostname === originalHost) {
refUrl.hostname = targetDomain;
proxyRequest.headers.set("Referer", refUrl.toString());
} else {
proxyRequest.headers.set("Referer", referer);
}
} catch {
// If Referer is malformed, leave it as-is
proxyRequest.headers.set("Referer", referer);
}
}

// Tell the origin the real public hostname & protocol the user is on.
// Useful for canonical URLs, server-side rendered analytics, hreflang, etc.
proxyRequest.headers.set("X-Forwarded-Host", originalHost);
proxyRequest.headers.set("X-Forwarded-Proto", "https");

// Cloudflare automatically adds these (no action needed, listed for reference):
// CF-Connecting-IP -> real client IP (authoritative)
// CF-IPCountry -> ISO country code
// CF-IPCity, CF-IPLatitude, CF-IPLongitude (on some plans)
// X-Forwarded-For -> appended with client IP
//
// Modern Client Hints sent by Chromium browsers (Sec-CH-UA-*, Sec-CH-UA-Mobile,
// Sec-CH-UA-Platform, etc.) are in request.headers already and we don't strip
// them, so device detection on the origin keeps working.


// 4. Fetch the response from the booking engine
let response = await fetch(proxyRequest);
response = new Response(response.body, response);


// Remove strict security headers so it renders on your domain
response.headers.delete("X-Frame-Options");
response.headers.delete("Content-Security-Policy");
// Also drop the report-only variant if present
response.headers.delete("Content-Security-Policy-Report-Only");


// 5. Intercept server redirects to hide the long tenant URL
if ([301, 302, 303, 307, 308].includes(response.status) && response.headers.has("Location")) {
let location = response.headers.get("Location");
location = location.replace(`https://${targetDomain}`, `https://${originalHost}`);
location = location.replace(hiddenPath, "");
response.headers.set("Location", location);
}

// 6. Rewrite Set-Cookie domain attribute so first-party cookies (incl. _ga,
// _ga_*, _gid) are scoped to YOUR domain, not the booking engine domain.
// This is critical for GA4 cross-page session continuity.
//
// Workers expose multi-value Set-Cookie via headers.getSetCookie() (or
// iterating headers). We rewrite each value and re-set them.
const setCookies = response.headers.getSetCookie
? response.headers.getSetCookie()
: [];
if (setCookies.length > 0) {
response.headers.delete("Set-Cookie");
for (const cookie of setCookies) {
// Replace any Domain=...targetDomain with our public host.
// Match both "Domain=bookingengine.casablanca.at" and ".bookingengine.casablanca.at"
const rewritten = cookie
.replace(new RegExp(`Domain=\\.?${targetDomain.replace(/\./g, "\\.")}`, "gi"), `Domain=${originalHost}`);
response.headers.append("Set-Cookie", rewritten);
}
}

// 7. Scrub the HTML (hides the tenant ID from the frontend source code)
const contentType = response.headers.get("Content-Type") || "";
if (contentType.includes("text/html")) {
let html = await response.text();

const domainRegex = new RegExp(`https://${targetDomain.replace(/\./g, "\\.")}`, 'g');
html = html.replace(domainRegex, `https://${originalHost}`);

// Escape the tenantId/spaceName before building regexes out of them,
// in case either ever contains a regex metacharacter.
const escapedHiddenPath = hiddenPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

// 7a. Locale-prefixed links: "/en/<tenant>/<space>/rest" -> "/en/rest".
// Step 1 puts the tenant path back on the way in, so these keep working.
html = html.replace(
new RegExp(`/([a-zA-Z]{2})${escapedHiddenPath}(?=[/?"'\\\\]|$)`, 'g'),
'/$1'
);

// 7b. Locale-LESS links, i.e. the tenant path at the very start of a quoted
// string value: `href="/<tenant>/<space>?..."` -> `href="/en?..."`.
// The IBE emits the "back to reservation page" link without a locale;
// stripping the tenant path to "" left a bare `?query`, which browsers
// resolve against the CURRENT page (the "Zurück" button bug). We swap in
// the current locale instead, which step 1 expands back to the full path.
//
// The quote anchor also covers the escaped JSON form inside the Next.js
// flight payload (\"href\":\"/<tenant>/<space>?...\"). That payload is what
// React hydrates from, so missing it means the fixed HTML gets reverted.
//
// Crucially, requiring a quote immediately before the tenant path means
// we DON'T touch paths where it appears mid-string, e.g. the SWR prefetch
// cache key "/api/<tenant>/<space>/booking-offers/...". Blindly stripping
// that broke the cache key match and forced a redundant client refetch.
html = html.replace(
new RegExp(`(["'])${escapedHiddenPath}(?=[/?"'\\\\])`, 'g'),
`$1/${currentLocale}`
);

return new Response(html, {
status: response.status,
statusText: response.statusText,
headers: response.headers
});
}

return response;
},
};

Schritt 4: Eigene Domain zum Worker routen​

Jetzt, wo die Proxy-Logik läuft, musst du Cloudflare mitteilen, dass der Worker bei jedem Aufruf deiner Domain (z. B. booking.yourhotel.com) ausgeführt werden soll.

  1. Gehe zurück zum Cloudflare-Dashboard und klicke auf deine Website-Domain.
  2. Klicke in der linken Seitenleiste auf Workers Routes (je nach Ansicht unter Workers & Pages oder Rules).
  3. Klicke auf Add Route.
  4. Definiere folgende Parameter:
    • Route – Gib deine Domain mit einem Platzhalter am Ende ein, zum Beispiel booking.yourhotel.com/*.
    • Worker – Wähle den Worker booking-proxy aus, den du in Schritt 2 erstellt hast.
  5. Klicke auf Save.

Schritt 5: DNS-Eintrag prüfen​

Damit Cloudflare den Datenverkehr deiner Subdomain (z. B. booking) abfangen kann, muss es dafür einen DNS-Eintrag geben.

  1. Öffne im Cloudflare-Dashboard den Bereich DNS.
  2. Stelle sicher, dass ein A-Eintrag (oder CNAME) für deine gewählte Subdomain vorhanden ist:
    • Type – A
    • Name – booking (oder die Subdomain, die du gewählt hast)
    • IPv4 address – 192.0.2.1 (Das ist eine Platzhalter-IP, die nötig ist, um das Cloudflare-Routing zu aktivieren. Der Worker fängt den Datenverkehr ab, bevor er diese IP erreicht.)
    • Proxy status – 🟠 Proxied (zwingend erforderlich!)

Schritt 6: Booking Engine testen​

Geschafft! Du lieferst deine Booking Engine jetzt über einen Proxy aus.

  • Öffne den Browser und rufe deine eigene Domain mit angehängtem Sprachcode auf (z. B. https://booking.yourhotel.com/de/).

Die Booking Engine sollte nahtlos laden. Die Adresszeile bleibt sauber, deine Tenant-IDs bleiben vollständig verborgen und URL-Parameter (wie ?numberOfRooms=1) funktionieren einwandfrei.

Wichtige Hinweise​


  • Verantwortung: Einrichtung und Betrieb des Reverse Proxys liegen ausschließlich beim Betrieb oder der betreuenden Agentur.
  • Keine Zusatzkosten: Für die Nutzung einer eigenen Domain sind keine zusätzlichen Zugänge oder Rechte in der CASABLANCA Cloud erforderlich.
  • Support: CASABLANCA bietet keinen Support für Reverse-Proxy-Implementierungen über die bereitgestellte Dokumentation hinaus.
  • Alternative: Die Booking Engine ist jederzeit über den direkten Systemlink erreichbar. Eine eigene Domain ist optional und Teil der jeweiligen Infrastruktur des Betriebs.

→ Siehe Standardintegration
→ Siehe Übergabe von URL-Parametern