> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kameleoon.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Erweiterte Optionen

> Dieser Leitfaden erlaeutert zusaetzliche erweiterte Implementierungsoptionen, die Kameleoon bietet.

## Einwilligungsverwaltung

Abhaengig vom Land, in dem Sie Ihre Website betreiben, muessen Sie moeglicherweise die Einwilligung verwalten, bevor Sie Daten ueber Ihre Besucher erheben. Mehr dazu lesen Sie in der [Dokumentation](../../privacy-and-compliance/consent-management).

## Geraeteuebergreifende Verlaufsabstimmung

Die Funktion zur geraeteuebergreifenden Verlaufsabstimmung von Kameleoon fuehrt den Verlauf und die Aktionen eines Nutzers ueber verschiedene Geraete hinweg zusammen. Wenn ein Nutzer eine Website mehrmals ueber unterschiedliche Geraete besucht, identifiziert Kameleoon ihn als wiederkehrenden Besucher und meldet die Anzahl der Besuche genau. Diese Funktion ist einfach zu aktivieren, solange Sie Nutzer identifizieren koennen, in der Regel ueber eine Kundenanmeldung.

Durch die Verwendung der geraeteuebergreifenden Verlaufsabstimmung gewinnen Sie drei wesentliche Vorteile:

* Ein kohaerentes Targeting-System, das alle Besuche und Aktionen ueber Geraete hinweg beruecksichtigt.
* Sicherstellen, dass ein Besucher fuer ein bestimmtes A/B-Experiment dieselbe Variation sieht, unabhaengig vom verwendeten Geraet.
* Ein praezises und genaues Reporting-System, das eindeutige Besucher korrekt zaehlt.

Weitere Informationen zu dieser Funktion finden Sie in dieser [Dokumentation](../../cross-device-experimentation).

## ITP-Verwaltung

Wenn ein erheblicher Teil des Traffics Ihrer Website von Mobilgeraeten stammt, implementieren Sie eine Cookie-Synchronisationsmethode, um Probleme mit Intelligent Tracking Prevention (ITP) auf Safari zu vermeiden. Weitere technische Details zur ITP-Verwaltung finden Sie in der [Dokumentation](../technical-concepts/itp-management).

Es gibt mehrere Optionen zur Synchronisierung des **visitorCode**-Identifiers (ueber das Cookie **kameleoonVisitorCode**) zwischen Front-End und Back-End, um ITP-Probleme auf Safari zu vermeiden. Zu diesen Optionen gehoeren:

* Aenderung Ihrer vorgeschalteten Webserver- oder Content-Delivery-Network-(CDN)-Konfiguration zur Erzeugung und Hinzufuegung des Cookies **kameleoonVisitorCode**. Kameleoon kann Anweisungen fuer Akamai bereitstellen.
* Implementierung eines bestimmten Code-Snippets auf Ihrem [Backend-Server](#java) (Java, NodeJS oder einer anderen Sprache).

### Nginx-Code-Snippet

Verwenden Sie fuer die Integration mit Nginx das folgende Code-Snippet:

```text theme={null}
server {
    listen 80;
    server_name MY_DOMAIN;

    set $visitorCode "";

        if ($http_cookie ~* "kameleoonVisitorCode=([^;]+)") {
        set $visitorCode $1;
    }

        if ($visitorCode = "") {
        set_by_lua_block $visitorCode '{
            local alphabet = "abcdefghijklmnopqrstuvwxyz0123456789" 
            local code = "" 
            for i = 1, 16 do
                local randomNumber = math.random(1, #alphabet)
                code = code .. alphabet:sub(randomNumber, randomNumber)
            end
            return code
        }';
    }

    location / {
        add_header Set-Cookie "kameleoonVisitorCode=$visitorCode; Expires=$expires; Path=/; Domain=MY_DOMAIN;";
        return 204; 
    }
}
```

### Backend-Code-Snippets

Sie koennen eines der Back-End-Code-Snippets entweder auf einer einzelnen URL Ihrer Haupt-Top-Level-Domain oder auf jeder Seite hosten. Wenn Sie sich fuer einen einzelnen Endpoint entscheiden, ruft Kameleoon den angegebenen Endpoint einmal pro Sitzung auf, um sicherzustellen, dass Ihr Server das Cookie **kameleoonVisitorCode** setzt. Dieser Aufruf erfolgt asynchron, nachdem die Seite vollstaendig geladen wurde. Wenden Sie sich an Ihren Customer Success Manager, um diese Option zu aktivieren. Kameleoon benoetigt die von Ihnen gewaehlte URL.

<Note>
  Der von Ihnen erstellte Synchronisations-Endpoint sollte keine Daten zurueckgeben. Ein Antwortcode `204 No Content` ist ausreichend. Dieser Endpoint wird ausschliesslich zum Setzen eines serverseitigen Cookies verwendet und sollte eine `GET`-Anfrage akzeptieren, die mit dem folgenden Code an die von Ihnen definierte Sync-URL gesendet wird:

  ```text theme={null}
  const e = new XMLHttpRequest;
  e.open("GET", Kameleoon.Internals.configuration.synchronizationEndpointURL + "?visitorCode=" + this.visitorCode, !0);
  ```
</Note>

Wenn Sie das Back-End-Code-Snippet auf jeder Seite einbetten, sind keine zusaetzlichen Aktionen erforderlich. Das Cookie wird automatisch erstellt, wenn normale Seitenanfragen an Ihre Server gestellt werden.

<Check>
  Sie koennen Ihren eigenen **Visitor Code** angeben, in der Regel einen eindeutigen Bezeichner aus Ihrer Datenbank, anstatt sich auf die automatische Generierung zu verlassen. Stellen Sie sicher, dass der von Ihnen angegebene visitorCode fuer jeden Besucher eindeutig ist, um genaue Daten fuer Ihre Experimente zu gewaehrleisten.
</Check>

Wenn Sie sowohl Kameleoon Web als auch Feature Experiments mit einem der [serverseitigen SDKs](../../feature-experimentation/get-started/overview#serverseitige-sdks) verwenden, koennen Sie direkt die Methode `getVisitorCode()` nutzen. Diese Hilfsmethode ruft automatisch den Kameleoon-**Visitor Code** fuer den aktuellen Besucher ab und erstellt das Cookie im Back-End.

#### Java

```java theme={null}
javax.servlet.http.HttpServletRequest request; // Provide a reference to the HttpServletRequest
javax.servlet.http.HttpServletResponse response; // Provide a reference to the HttpServletResponse
String topLevelDomain = "MY_DOMAIN";// Here you must provide your own base domain, eg mydomain.com
String visitorCode = null; // Here you can provide your own identifier if needed, else it will be generated randomly

String cookiesHeader = request.getHeader("Cookie");
if (cookiesHeader != null) {
	String[] cookies = cookiesHeader.split(";");
	for (String cookieNameAndValue : cookies) {
		String[] cookieNameAndValuePair = cookieNameAndValue.split("=");
		if (cookieNameAndValuePair[0].trim().equals("kameleoonVisitorCode")) {
			visitorCode = cookieNameAndValuePair[1];
		}
	}
}
if (visitorCode == null) {
	final String alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
	final int alphabetLength = alphabet.length();
	final int visitorCodeLength = 16;
	final StringBuilder visitorCodeBuilder = new StringBuilder(visitorCodeLength);
	for (int i = 0; i < visitorCodeLength; ++i) {
		visitorCodeBuilder.append(
				alphabet.charAt(java.util.concurrent.ThreadLocalRandom.current().nextInt(alphabetLength))
		);
	}
	visitorCode = visitorCodeBuilder.toString();
}

javax.servlet.http.Cookie cookie = new Cookie("kameleoonVisitorCode", visitorCode);
cookie.setMaxAge(32_832_000);
cookie.setHttpOnly(false); // The cookie must be accessible from the front-end since it stores the visitorCode, which Kameleoon uses to bucket users into experiments and track their activity.
cookie.setPath("/");
cookie.setDomain(topLevelDomain);
response.addCookie(cookie);
```

#### NodeJS

```js theme={null}
let topLevelDomain = "MY_DOMAIN";// Here you must provide your own base domain, eg mydomain.com
let visitorCode = null; // Here you can provide your own identifier if needed, else it will be generated randomly

request.headers && request.headers.cookie.split(';').forEach(function (cookie) {
	let cookieNameAndValuePair = cookie.match(/(.*?)=(.*)$/);
	if (cookieNameAndValuePair[1].trim() == "kameleoonVisitorCode") {
		visitorCode = cookieNameAndValuePair[2].trim();
	}
});
if (!visitorCode) {
	let alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
	let alphabetLength = alphabet.length;
	visitorCode = "";
	for (let i = 0; i < 16; ++i) {
		let randomNumber = Math.floor(Math.random() * alphabetLength);
		visitorCode += alphabet[randomNumber];
	}
}

let expires = new Date(new Date().getTime() + 32832000000);
response.writeHead(200, {
		'Set-Cookie': [`kameleoonVisitorCode=${visitorCode}; expires=${expires}; path=/; domain=${topLevelDomain};`]
});
```

#### PHP

```php theme={null}
<?php
$topLevelDomain = "MY_DOMAIN";// Here you must provide your own base domain, eg mydomain.com
$visitorCode = NULL; // Here you can provide your own identifier if needed, else it will be generated randomly

if (isset($_COOKIE["kameleoonVisitorCode"])) {
	$visitorCode = $_COOKIE["kameleoonVisitorCode"];
}
if (is_null($visitorCode)) {
	$alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
	$alphabetLength = strlen($alphabet);
	$visitorCode = "";
	for ($i = 0; $i < 16; $i++) {
		$randomNumber = floor((mt_rand() / mt_getrandmax()) * $alphabetLength);
		$visitorCode .= substr($alphabet, $randomNumber, 1);
	}
}

setcookie("kameleoonVisitorCode", $visitorCode, time() + 32832000, "/", $topLevelDomain);
?>
```

Kopieren Sie diesen Code, fuegen Sie ihn ein und ersetzen Sie MY\_DOMAIN durch Ihre Top-Level-Basisdomain (d. h. mydomain.com).

#### C\#

<Tabs>
  <Tab title=".NET Core">
    ```csharp theme={null}
    System.Security.Cryptography.RandomNumberGenerator rng; // A concurrent RNG for generating unique visitor codes
    Microsoft.AspNetCore.Http.HttpRequest request; // Provide a reference to the HttpRequest
    Microsoft.AspNetCore.Http.HttpResponse response; // Provide a reference to the HttpResponse
    string topLevelDomain = "MY_DOMAIN";// Here you must provide your own base domain, eg mydomain.com
    string visitorCode = null; // Here you can provide your own identifier if needed, else it will be generated randomly

    if (request.Cookies.ContainsKey("kameleoonVisitorCode"))
    visitorCode = request.Cookies["kameleoonVisitorCode"];

    if (visitorCode == null)
    {
    const string alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
    const int visitorCodeLength = 16;
    char[] visitorCodeBuffer = new char[visitorCodeLength];
    byte[] randBuffer = new byte[visitorCodeLength];
    rng.GetBytes(randBuffer);
    for (int i = 0; i < visitorCodeLength; i++)
        visitorCodeBuffer[i] = alphabet[randBuffer[i] % alphabet.Length];
    visitorCode = new string(visitorCodeBuffer);
    }

    var cookieOptions = new Microsoft.AspNetCore.Http.CookieOptions.CookieOptions();
    cookieOptions.Expires = DateTime.Now.AddSeconds(32_832_000);
    cookieOptions.HttpOnly = false; // The cookie must be accessible from the front-end since it stores the visitorCode, which Kameleoon uses to bucket users into experiments and track their activity.
    cookieOptions.Path = "/";
    cookieOptions.Domain = topLevelDomain;
    response.Cookies.Append("kameleoonVisitorCode", visitorCode, cookieOptions);
    ```
  </Tab>

  <Tab title=".NET Framework">
    ```csharp theme={null}
    System.Security.Cryptography.RandomNumberGenerator rng; // A concurrent RNG for generating unique visitor codes
    System.Web.HttpRequest request; // Provide a reference to the HttpRequest
    System.Web.HttpResponse response; // Provide a reference to the HttpResponse
    string topLevelDomain = "MY_DOMAIN";// Here you must provide your own base domain, eg mydomain.com
    string visitorCode = null; // Here you can provide your own identifier if needed, else it will be generated randomly

    if (request.Cookies.Get("kameleoonVisitorCode") != null)
    visitorCode = request.Cookies.Get("kameleoonVisitorCode").Value;

    if (visitorCode == null)
    {
    const string alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
    const int visitorCodeLength = 16;
    char[] visitorCodeBuffer = new char[visitorCodeLength];
    byte[] randBuffer = new byte[visitorCodeLength];
    rng.GetBytes(randBuffer);
    for (int i = 0; i < visitorCodeLength; i++)
        visitorCodeBuffer[i] = alphabet[randBuffer[i] % alphabet.Length];
    visitorCode = new string(visitorCodeBuffer);
    }

    var cookie = new System.Web.HttpCookie("kameleoonVisitorCode", visitorCode);
    cookie.Expires = DateTime.Now.AddDays(380);
    cookie.HttpOnly = false; // The cookie must be accessible from the front-end since it stores the visitorCode, which Kameleoon uses to bucket users into experiments and track their activity.
    cookie.Path = "/";
    cookie.Domain = topLevelDomain;
    response.Cookies.Add(cookie);
    ```
  </Tab>
</Tabs>

#### Go

```go theme={null}
var request *fasthttp.Request // Provide a reference to the Request
var response *fasthttp.Response // Provide a reference to the Response
const topLevelDomain = "MY_DOMAIN" // Here you must provide your own base domain, eg mydomain.com
var visitorCode string // Here you can provide your own identifier if needed, else it will be generated randomly

if binaryVisitorCode := request.Header.Cookie("kameleoonVisitorCode"); binaryVisitorCode != nil {
	visitorCode = string(binaryVisitorCode)
}
if visitorCode == "" {
	const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789"
	const visitorCodeLength = 16
	visitorCodeBuilder := strings.Builder{}
	visitorCodeBuilder.Grow(visitorCodeLength)
	randomBuffer := make([]byte, visitorCodeLength)
	if _, err := rand.Read.Read(randomBuffer); err != nil { // crypto/rand
		// handle error
	}
	for i := 0; i < visitorCodeLength; i++ {
		visitorCodeBuilder.WriteByte(alphabet[randomBuffer[i] % len(alphabet)])
	}
	visitorCode = visitorCodeBuilder.String()
}

ck := fasthttp.AcquireCookie()
ck.SetKey("kameleoonVisitorCode")
ck.SetValue(visitorCode)
ck.SetExpire(time.Now().Add(380 * 24 * time.Hour))
ck.SetHTTPOnly(false) // The cookie must be accessible from the front-end since it stores the visitorCode, which Kameleoon uses to bucket users into experiments and track their activity.
ck.SetPath("/")
ck.SetDomain(topLevelDomain)
response.Header.SetCookie(ck)
fasthttp.ReleaseCookie(ck)
```

#### Python

```python theme={null}
import random

topLevelDomain = "MY_DOMAIN" # Here you must provide your own base domain, eg mydomain.com

# Here you can provide your own identifier via customer_visitor_code if needed, else it will be generated randomly
def fill_visitor_code(request, response, customer_visitor_code):
    visitor_code = request.cookies.get("kameleoonVisitorCode")
    if "kameleoonVisitorCode" in request.cookies:
        visitor_code = request.cookies.get("kameleoonVisitorCode")
    else:
        visitor_code = customer_visitor_code if customer_visitor_code is not None else "".join(
            random.choice(string.ascii_lowercase + string.digits) for _ in range(16)
        )
    response.set_cookie("kameleoonVisitorCode", visitor_code, max_age=32832000, domain=topLevelDomain)

fill_visitor_code(request, response) # The method must be called with correct arguments (depending on your Python web framework)
```

#### Ruby

```ruby theme={null}
# Define constants
KAMELEOON_COOKIE_VALUE_LENGTH = 16
KAMELEOON_COOKIE_NAME = 'kameleoonVisitorCode'.freeze
EXPIRE_DAYS = 365

# Method to generate a random visitor code
def generate_visitor_code(length)
  alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789'
  alphabet_length = alphabet.length
  visitor_code = ''

  length.times do
    random_number = rand(alphabet_length)
    visitor_code.concat(alphabet[random_number])
  end

  visitor_code
end

# Main code
top_level_domain = 'MY_DOMAIN' # Replace with your actual domain
visitor_code = cookies[KAMELEOON_COOKIE_NAME]

visitor_code = generate_visitor_code(KAMELEOON_COOKIE_VALUE_LENGTH) if visitor_code.nil? || visitor_code.empty?

kameleoon_cookie = {
  value: visitor_code,
  expires: Time.now + 60 * 60 * 24 * EXPIRE_DAYS,
  path: '/',
  domain: top_level_domain
}

cookies[KAMELEOON_COOKIE_NAME] = kameleoon_cookie
```

## Eine benutzerdefinierte Domain verwenden

Wenn Sie Ihre eigene Domain anstelle der Standarddomain von Kameleoon verwenden moechten oder wenn Werbeblocker einige Nutzer daran hindern, in Experimente einbezogen zu werden, bietet Kameleoon eine Premium-Option zur Einrichtung einer benutzerdefinierten Domain und zur Umgehung der Erkennung.

[Erfahren Sie mehr darueber, wie Sie eine benutzerdefinierte Domain aktivieren.](../../feature-experimentation/technical-reference/faq-global#how-do-ad-blockers-affect-kameleoon)

## Ihren eigenen CDN- oder Hosting-Server verwenden (Self-Hosting)

Die Kameleoon-Anwendungsdatei `engine.js` (frueher `kameleoon.js` genannt) kann entweder auf dem Kameleoon-CDN oder auf Ihren eigenen CDN- oder Servern gehostet werden. Sie auf Ihren eigenen Servern zu hosten, kann eine geringfuegige Leistungsverbesserung bieten, indem eine zusaetzliche DNS-Abfrage und ein SSL-Handshake vermieden werden, die das Kameleoon-CDN erfordert. Zudem kann Self-Hosting aus Sicherheitsgruenden bevorzugt werden, da Sie die Einhaltung Ihrer internen Sicherheitsrichtlinien sicherstellen und die Verantwortung fuer die Sicherheit Ihrer Hosting-Server uebernehmen koennen.

Wenn Sie die Kameleoon-Anwendungsdatei selbst hosten moechten, lesen Sie die [Self-Hosting](../self-hosting/simple-self-hosting-and-on-premises-options#selbst-hosting-der-anwendungsdatei)-Dokumentation.