> For the complete documentation index, see [llms.txt](https://doc.commandersact.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://doc.commandersact.com/fr/developpeurs/commanders-tag-gateway.md).

# Commanders Act Gateway

Ce document décrit comment déployer **Commanders Act Gateway**, un **gateway first-party unifié** qui utilise **une seule configuration et un seul chemin sur votre domaine** pour alimenter plusieurs cas d'usage de tracking et d'hébergement.

Commanders Act Gateway inclut **Google Tag Gateway**, mais **ne se limite pas à Google**.\
Il est conçu pour servir et collecter des données pour **tous vos partenaires marketing et analytics**, en utilisant la même infrastructure first-party.

Une seule configuration, un seul chemin first-party, trois usages :

* Google Tag Gateway (GA4, Google Ads)
* Tracking first-party vers toutes les destinations server-side
* Hébergement first-party de bibliothèques third-party

Si votre objectif est de mettre en place Google Tag Gateway, vous êtes au bon endroit.\
Si votre objectif est de construire une architecture de tracking first-party durable et agnostique vis-à-vis des fournisseurs, vous êtes également au bon endroit.

<figure><img src="/files/08d40204a03ccec4c9f251bfaa11f7e811dd1be7" alt=""><figcaption></figcaption></figure>

***

## Pourquoi utiliser Commanders Gateway ?

### 1. Avantages de l'utilisation d'un gateway

Une configuration gateway améliore **la qualité et l'exhaustivité de la collecte de données** sur l'ensemble de votre stack marketing.

* Les scripts des fournisseurs sont servis depuis votre propre domaine, ce qui réduit la probabilité d'être bloqué par les bloqueurs de publicités.
* Les restrictions du navigateur (comme l'ITP de Safari) limitent ou bloquent souvent les cookies third-party et certains cookies javascript 1st party, mais avec une configuration first-party server-side, la mesure reste plus fiable.
* Cela garantit **un tracking plus précis**, en fournissant aux partenaires des signaux de meilleure qualité pour la mesure, l'attribution et l'optimisation.

### 2. Avantages de l'utilisation de Commanders Gateway

En plus des bénéfices de toute approche gateway, **Commanders Gateway** offre des avantages uniques :

* Non limité à Google Tag Gateway — la même configuration durable s'applique à **tous vos partenaires** (Meta, Snapchat, Bing, Awin, etc.).
* Configuration unifiée : un **chemin unique** (`/mypath`) sert et relaie toutes les bibliothèques des fournisseurs.
* Des noms de fichiers JavaScript obfusqués sont automatiquement fournis par Commanders Act, ce qui rend beaucoup plus difficile leur détection par les listes de blocage.
* Avec le même chemin simple, vous pouvez également activer d'autres **fonctionnalités d'hébergement first-party et de tracking** telles que : héberger vos conteneurs de gestion de tags, le tracking d'événements server-side, ou des statistiques CMP anonymes. Une seule configuration alimente l'ensemble de votre système d'hébergement et de tracking first-party.
* Une configuration centralisée simplifie le déploiement et la maintenance tout en restant **à l'épreuve du futur** face aux prochaines restrictions des navigateurs.

***

## Vue d'ensemble

**Commanders Gateway** vous permet de déployer des tags marketing et de mesure en utilisant votre **propre infrastructure first-party**, hébergée sur le domaine de votre site web.\
Cette infrastructure se situe entre votre site web et les services de vos partenaires (Google, Meta, Bing, Snapchat, Awin, etc.).

Avec Commanders Gateway :

* Les bibliothèques Google (gtag.js / gtm.js) sont chargées directement depuis votre **domaine first-party**.
* Les autres bibliothèques des fournisseurs sont servies depuis `/mypath/js/` en utilisant **des noms de fichiers obfusqués**.
* Toutes les requêtes de mesure sont relayées via votre domaine avant d'être transmises aux endpoints correspondants des partenaires.

***

## Architecture

Avec **Commanders Gateway**, vous réservez un **chemin unique** sur votre domaine, par exemple :

```
https://example.com/mypath/
```

* **Scripts Google** (gtag.js / gtm.js) sont chargés directement depuis `/mypath/`.
* **Les scripts des autres fournisseurs** (Meta, Snapchat, Bing, Awin, etc.) sont servis depuis `/mypath/js/` avec un **nom de fichier obfusqué** généré par Commanders Act.

Exemple :

```
https://example.com/mypath/js/f4558899203.js
```

Le mappage entre chaque fournisseur et son nom de fichier de script obfusqué est fourni dans l' **interface d'hébergement first-party de Commanders Act**.

**Schéma (conceptuel) :**

```
Site web  →  example.com/mypath/ (Google tags)
         →  example.com/mypath/js/f4558899203.js (Meta, Snap, Bing…)
         →  Commanders Gateway  →  endpoint du fournisseur
```

***

## Filtrage et gouvernance des cookies

Certaines organisations, en particulier celles ayant des politiques de confidentialité strictes, peuvent s'inquiéter d'envoyer **des cookies first-party à des partenaires externes** comme Google. Commanders Gateway prend en charge **la minimisation des données** et fournit des mécanismes pour contrôler quels cookies peuvent transiter par le gateway. Deux approches complémentaires peuvent être utilisées :

#### Liste noire de cookie en edge

Les clients peuvent filtrer les cookies **directement au niveau du CDN ou de la couche edge** (Cloudflare Worker, Fastly Compute, etc.). Cela peut être fait en **configurant simplement le code du Worker fourni dans ce guide** (voir les onglets CloudFlare free ou Faslty ci-dessous) pour supprimer des cookies spécifiques avant que la requête ne soit transmise à Commanders Gateway.

Cela permet de supprimer des cookies spécifiques de la requête **avant qu'elle n'atteigne Commanders Gateway**, garantissant que seuls les cookies approuvés par l'organisation quittent son infrastructure.

#### Liste blanche de cookie avant transmission aux partenaires

Commanders Gateway peut également imposer une **liste blanche de cookie lors de la transmission des requêtes aux partenaires**.

Par exemple, lors de la transmission des requêtes de mesure à Google, le gateway peut être configuré pour **inclure uniquement les cookies liés à Google** (tels que `_ga` ou `_gcl_*`).\
Tous les autres cookies sont automatiquement exclus de la requête envoyée à Google.

## Avant de commencer

Ce guide suppose que votre site web est déjà configuré avec :

* Un système de gestion de tags (Commanders Act, Google Tag Manager, ou équivalent).
* Un CDN ou un équilibreur de charge (Cloudflare, Akamai, Fastly, Nginx, etc.) capable de relayer les requêtes vers des endpoints externes.

***

## Étape 1 : Choisir le chemin de service des tags

Vous devez réserver **un chemin** sur le domaine de votre site web.

Exemple :

```
/mypath
```

Attention : cette configuration redirige tout le trafic utilisant le chemin choisi. Pour éviter d'affecter votre site web, choisissez un chemin qui n'est pas déjà utilisé.

***

## Étape 2 : Acheminer le trafic

{% tabs %}
{% tab title="Cloudflare Enterprise" %}
Lors de l'utilisation de Cloudflare Enterprise, nous recommandons d'utiliser un **Cloudflare Worker** pour proxyfier tout le trafic provenant de votre chemin choisi, par exemple `/mypath`, vers l'infrastructure Commanders Gateway.

Cette approche est la même que la configuration Cloudflare Free. Elle est plus fiable que d'essayer d'acheminer le chemin avec les Cloudflare Origin Rules, car le Worker donne un contrôle total sur l'URL de la requête, les en-têtes, le filtrage des cookies et la transmission de la géolocalisation.

**Étape 1 : Créer le Worker**

1. Dans le Dashboard Cloudflare, allez à **Workers & Pages** → **Créer une application** → **Worker**.
2. Copiez/collez le code suivant :

```javascript
const prefix = "/mypath"; // Exemple de chemin, remplacez-le par le chemin choisi à l'étape précédente
const sid = "12345"; // Exemple d'ID de workspace (alias ID de site), remplacez-le par votre propre ID

// Liste des noms de cookies qui ne doivent PAS être transmis à Commanders Gateway. Vous pouvez ajouter vos cookies techniques si nécessaire
const blacklistedCookies = [
  "PHPSESSID",
  "JSESSIONID"
];

addEventListener("fetch", event => {
  event.respondWith(handleRequest(event.request));
});

function filterCookieHeader(cookieHeader, blacklist) {
  if (!cookieHeader) return "";

  const blacklistSet = new Set(blacklist);

  const filteredCookies = cookieHeader
    .split(";")
    .map(cookie => cookie.trim())
    .filter(cookie => {
      const cookieName = cookie.split("=")[0];
      return !blacklistSet.has(cookieName);
    });

  return filteredCookies.join("; ");
}

async function handleRequest(request) {
  const url = new URL(request.url);

  if (url.pathname.startsWith(prefix)) {
    // Construire l'URL cible. Elle remplace ${sid} par votre ID de workspace/site ci-dessus.
    const targetUrl = `https://s${sid}.commander4.com${url.pathname}${url.search}`;

    // Cloner les en-têtes de la requête
    const newHeaders = new Headers(request.headers);
    newHeaders.set("X-Forwarded-Host", url.host);

    const country = request.cf?.country || "";
    const region = request.cf?.region || "";

    if (country) newHeaders.set("X-Forwarded-Country", country);
    if (region) newHeaders.set("X-Forwarded-Region", region);
    if (country && region) {
      newHeaders.set("X-Forwarded-CountryRegion", `${country}-${region}`);
    }

    // Filtrer l'en-tête Cookie avant de proxyfier la requête.
    const cookieHeader = newHeaders.get("Cookie");
    const filteredCookies = filterCookieHeader(cookieHeader, blacklistedCookies);

    if (filteredCookies) {
      newHeaders.set("Cookie", filteredCookies);
    } else {
      newHeaders.delete("Cookie");
    }

    // Supprimer l'en-tête Host pour éviter les conflits
    newHeaders.delete("host");

    // Proxyfier la requête vers l'infrastructure Commanders Gateway
    const proxyRequest = new Request(targetUrl, {
      method: request.method,
      headers: newHeaders,
      body: request.body,
      redirect: "follow"
    });

    return fetch(proxyRequest);
  }

  return new Response("Non trouvé", { status: 404 });
}
```

Ce Worker proxyfie les requêtes tout en ajoutant des en-têtes supplémentaires :

* `X-Forwarded-Host`
* `X-Forwarded-Country`
* `X-Forwarded-Region`
* `X-Forwarded-CountryRegion`

Il peut aussi filtrer les cookies sensibles ou techniques avant de transmettre la requête à Commanders Gateway.

**Étape 2 : Associer le Worker au chemin**

1. Dans Cloudflare, ouvrez les paramètres de votre domaine.
2. Naviguez vers **Workers Routes**.
3. Ajoutez une nouvelle route avec :
   * **Modèle d'URL**: `www.example.com/mypath*`
   * **Worker**: sélectionnez le Worker créé à l'étape 1.

Une fois enregistré, toutes les requêtes vers `/mypath` seront proxyfiées vers Commanders Gateway.

**Étape 3 : Vérifier la configuration**

Vous pouvez vérifier la configuration en accédant à :

```
https://example.com/mypath/g/healthy
```

Note : le sous-chemin Google par défaut est /g/ mais il peut être personnalisé. Ce sous-chemin Google se trouve immédiatement après /mypath/ .

Il doit renvoyer :

```
ok
```

Pour vérifier la transmission de la géolocalisation, vous pouvez aussi tester :

```
https://example.com/mypath/g/?validate_geo=healthy
```

Il doit également renvoyer :

```
ok
```

{% endtab %}

{% tab title="Cloudflare Free" %}
Lors de l'utilisation de Cloudflare Free, la configuration repose sur un **Worker simple** qui proxyfie tout le trafic provenant de votre chemin choisi (par ex. `/mypath`) vers l'infrastructure Commanders Gateway.

**Étape 1 : Créer le Worker**

1. Dans le Dashboard Cloudflare, allez à **Workers & Pages** → **Créer une application** → **Worker**.
2. Copiez/collez le code suivant :

```javascript
const prefix = "/mypath"; // Exemple de chemin, remplacez-le par le chemin choisi à l'étape précédente
const sid = "12345"; // Exemple d'ID de workspace (alias ID de site), remplacez-le par votre propre ID

// Liste des noms de cookies qui ne doivent PAS être transmis à Commanders Gateway. Vous pouvez ajouter vos cookies techniques si nécessaire
const blacklistedCookies = [
  "PHPSESSID",
  "JSESSIONID"
];

addEventListener("fetch", event => {
  event.respondWith(handleRequest(event.request));
});

function filterCookieHeader(cookieHeader, blacklist) {
  if (!cookieHeader) return "";

  const blacklistSet = new Set(blacklist);

  const filteredCookies = cookieHeader
    .split(";")
    .map(cookie => cookie.trim())
    .filter(cookie => {
      const cookieName = cookie.split("=")[0];
      return !blacklistSet.has(cookieName);
    });

  return filteredCookies.join("; ");
}

async function handleRequest(request) {
  const url = new URL(request.url);
  if (url.pathname.startsWith(prefix)) {
    // Construire l'URL cible (elle remplace ${sid} par votre ID de workspace/site ci-dessus)
    const targetUrl = `https://s${sid}.commander4.com${url.pathname}${url.search}`;

    // Cloner les en-têtes de la requête
    const newHeaders = new Headers(request.headers);
    newHeaders.set("X-Forwarded-Host", url.host);

    const country = request.cf?.country || "";
    const region = request.cf?.region || "";
    if (country) newHeaders.set("X-Forwarded-Country", country);
    if (region) newHeaders.set("X-Forwarded-Region", region);
    if (country && region) {
      newHeaders.set("X-Forwarded-CountryRegion", `${country}-${region}`);
    }

    // Filtrer l'en-tête Cookie avant de proxyfier la requête.
    const cookieHeader = newHeaders.get("Cookie");
    const filteredCookies = filterCookieHeader(cookieHeader, blacklistedCookies);

    if (filteredCookies) {
      newHeaders.set("Cookie", filteredCookies);
    } else {
      newHeaders.delete("Cookie");
    }

    // Supprimer l'en-tête Host pour éviter les conflits
    newHeaders.delete("host");

    // Proxyfier la requête vers l'infrastructure Commanders Gateway
    const proxyRequest = new Request(targetUrl, {
      method: request.method,
      headers: newHeaders,
      body: request.body,
      redirect: "follow"
    });
    return fetch(proxyRequest);
  }
  return new Response("Non trouvé", { status: 404 }); // Renvoie 404 si le chemin de la requête ne correspond pas au préfixe
}
```

Ce Worker proxyfie les requêtes tout en ajoutant des en-têtes supplémentaires (`X-Forwarded-Host`, `X-Forwarded-Country`, `X-Forwarded-Region`).

**Étape 2 : Associer le Worker au chemin**

1. Dans Cloudflare, ouvrez les paramètres de votre domaine.
2. Naviguez vers **Workers Routes**.
3. Ajoutez une nouvelle route avec :
   * **Modèle d'URL**: `www.example.com/mypath*`
   * **Worker**: sélectionnez le Worker créé à l'étape 1.

Une fois enregistré, toutes les requêtes vers `/mypath` seront proxyfiées vers Commanders Gateway.
{% endtab %}

{% tab title="Akamai" %}
{% hint style="warning" %}
Commanders Gateway avec Akamai est en **beta**. Si vous avez une question ou un problème avec votre configuration, contactez le support
{% endhint %}

**Créer la règle de redirection**

1. Créez une nouvelle version de votre configuration de diffusion dans **Property Manager**.
2. Dans la **Property Configuration Settings** section, ajoutez une nouvelle règle :
   * Nommez-la : *Acheminement de la mesure*
3. Ajoutez un nouveau **Match**:
   * Type de correspondance : `Chemin`
   * Condition : *est l'un des*
   * Valeur : `/mypath/*`
4. Ajoutez un nouveau **Comportement**:
   * Sélectionnez *Comportement de propriété standard* et choisissez **Serveur d'origine** comportement.
   * Définissez **Nom d'hôte du serveur d'origine** sur `s1234.commander4.com.`
   * Définissez **Transmettre l'en-tête Host** sur *Nom d'hôte d'origine*.
5. Enregistrez la nouvelle règle et déployez vos modifications.
   * ⚠️ Testez la règle de redirection dans votre **environnement de staging** avant de la déployer en production.
   * Assurez-vous qu'aucune autre règle ne modifie/supprime les en-têtes de réponse sortants (par ex., *Content-Type*) car cela peut casser les scripts.

***

**Inclure les informations de géolocalisation**

1. Accédez à la **Variables de propriété** section et ajoutez les variables suivantes :

| Nom de la variable | Paramètres de sécurité |
| ------------------ | ---------------------- |
| USER\_REGION       | Masqué                 |
| USER\_COUNTRY      | Masqué                 |

2. Choisissez votre **règle de redirection** (créée ci-dessus) dans Property Configuration Settings.
3. Ajoutez deux nouveaux **comportements Set Variable** (un par variable) :

| Variable              | Créer la valeur à partir de | Obtenir les données depuis | Champ Edgescape | Opération |
| --------------------- | --------------------------- | -------------------------- | --------------- | --------- |
| PMUSER\_USER\_REGION  | Extraire                    | Données Edgescape          | Code région     | Aucun     |
| PMUSER\_USER\_COUNTRY | Extraire                    | Données Edgescape          | Code pays       | Aucun     |

4. Ajoutez deux nouveaux **Modifier les en-têtes de la requête sortante** comportements :

| Action  | Sélectionner le nom de l'en-tête | Nom d'en-tête personnalisé | Valeur de l'en-tête            |
| ------- | -------------------------------- | -------------------------- | ------------------------------ |
| Ajouter | Autre...                         | X-Forwarded-Region         | {{user.PMUSER\_USER\_REGION}}  |
| Ajouter | Autre...                         | X-Forwarded-Country        | {{user.PMUSER\_USER\_COUNTRY}} |

5. Enregistrez la nouvelle règle et déployez vos modifications.
6. Vérifiez la configuration :
   * Accédez à : `https://example.com/mypath/healthy` → doit afficher `ok`.
   * Tester les en-têtes de géolocalisation : `https://example.com/mypath/?validate_geo=healthy` → doit également afficher `ok`.
     {% endtab %}

{% tab title="Fastly" %}
{% hint style="warning" %}
La prise en charge de Fastly pour Commanders Gateway est actuellement en **beta**beta. Les étapes ci-dessous sont destinées aux utilisateurs techniques familiarisés avec Fastly Compute (Compute Services). Selon la configuration de votre compte Fastly (domaines, TLS, produits activés), certaines étapes de liaison en production peuvent varier.
{% endhint %}

Lors de l'utilisation de Fastly, la configuration est différente de Cloudflare. Vous déployez un **service Compute** (Wasm) et le configurez principalement via l' **API et le CLI de Fastly** depuis un terminal.

**Prérequis**

1. Créez un jeton API dans l'interface Fastly (les scopes doivent autoriser Compute, services, backends et déploiements).
2. Exportez le jeton dans votre environnement de terminal :

```
export FASTLY_API_TOKEN=XXXXXXXXXXXX
```

3. Installez les prérequis :

* Node.js
* Fastly CLI

**Étape 1 : créez le service Compute**

Créez un nouveau service Compute :

```
fastly service create --name "CA Gateway" --type wasm
```

Fastly renvoie un **ID du service**, par exemple :

```
dyBxiT8wpc2c8ZQg2KRrMN
```

Conservez-le, vous en aurez besoin pour la création du backend et les déploiements.

**Étape 2 : créez un projet Compute local (starter kit)**

Générez un projet local à partir du starter kit JavaScript par défaut :

```
npm create @fastly/compute@latest -- --language=javascript --default-starter-kit
```

Cela crée une structure de projet similaire à :

```
.
├── README.md
├── fastly.toml
├── package.json
└── src
    ├── index.js
    └── welcome-to-compute.html
```

**Étape 3 : configurez l'ID du service dans fastly.toml**

Modifiez `fastly.toml` et définissez l'ID du service :

```
# fastly.toml
service_id = "YOUR_SERVICE_ID"
```

**Étape 4 : créez le backend (origine Commanders Gateway)**

Créez un backend pointant vers l'infrastructure Commanders Gateway (remplacez `1234` par votre ID de workspace/site) :

```
fastly backend create \\
  --service-id YOUR_SERVICE_ID \\
  --version 1 \\
  --name commander_gateway \\
  --address s1234.commander4.com \\
  --use-ssl \\
  --port 443 \\
  --ssl-sni-hostname s1234.commander4.com
```

Notes :

* `--version 1` est un point de départ typique. Si votre service possède déjà des versions, utilisez la version que vous souhaitez déployer.
* L'adresse du backend doit être `s1234.commander4.com` (votre propre ID de workspace/site).

**Étape 5 : implémentez la logique de routage dans src/index.js**

Remplacez le contenu de `src/index.js` par le code worker suivant.

Vous devez mettre à jour :

* `préfixe` (votre chemin client, par exemple : `/mypath`)
* `sid` (votre ID de workspace/site Commanders, par exemple : `s1234`)

```javascript
/// <reference types="@fastly/js-compute" />

import { env } from "fastly:env";
import { includeBytes } from "fastly:experimental";

const prefix = "/PATHACHANGER";              // TODO: remplacez par le chemin de gateway que vous avez choisi (par ex. "/mypath")
const sid = "s123456";                       // TODO: remplacez par votre ID de workspace/site (par ex. "s1234")
const BACKEND = "commander_gateway";         // Nom du backend Fastly pointant vers sid.commander4.com

const STRIP_PREFIX = true;                   // Si true, supprime le préfixe du chemin transmis
const PREPEND_PATH = "/gateway";             // Point d'entrée interne de gateway côté Commanders (ne pas modifier)

// Liste des noms de cookie qui ne doivent PAS être transmis à Commanders Gateway. Ajoutez vos cookie techniques si nécessaire
const blacklistedCookies = [
  "PHPSESSID",
  "JSESSIONID"
];

addEventListener("fetch", (event) => event.respondWith(handleRequest(event.request)));

function filterCookieHeader(cookieHeader, blacklist) {
  if (!cookieHeader) return "";

  const blacklistSet = new Set(blacklist);

  const filteredCookies = cookieHeader
    .split(";")
    .map(cookie => cookie.trim())
    .filter(cookie => {
      const cookieName = cookie.split("=")[0];
      return !blacklistSet.has(cookieName);
    });

  return filteredCookies.join("; ");
}

async function handleRequest(request) {

  const url = new URL(request.url);

  // Proxy uniquement les requêtes qui correspondent au préfixe configuré
  if (!url.pathname.startsWith(prefix)) {
    return new Response("Non trouvé", { status: 404 });
  }

  // Construit le chemin qui sera transmis à Commanders Gateway
  let fwdPath = url.pathname;

  // Supprime éventuellement le préfixe client (par ex. "/mypath") afin que l'origine reçoive "/"
  if (STRIP_PREFIX) {
    fwdPath = fwdPath.slice(prefix.length) || "/";
  }

  // Ajoute le point d'entrée interne Commanders (obligatoire)
  if (PREPEND_PATH) {
    fwdPath = PREPEND_PATH + fwdPath;
  }

  // URL finale de l'origine sur l'infrastructure Commanders
  const target = `https://${sid}.commander4.com${fwdPath}${url.search}`;

  // Clone les headers et ajoute les informations de transmission
  const headers = new Headers(request.headers);
  headers.set("X-Forwarded-Host", url.host);

  // Transmet les informations géo lorsqu'elles sont disponibles (facultatif mais recommandé)
  const country = (request.geo && request.geo.country_code) ? request.geo.country_code.toUpperCase() : "";
  const region  = (request.geo && request.geo.region) ? request.geo.region : "";
  if (country) headers.set("X-Forwarded-Country", country);
  if (region)  headers.set("X-Forwarded-Region", region);
  if (country && region) headers.set("X-Forwarded-CountryRegion", `${country}-${region}`);

  // Filtrer l'en-tête Cookie avant de proxyfier la requête.
  const cookieHeader = headers.get("Cookie");
  const filteredCookies = filterCookieHeader(cookieHeader, blacklistedCookies);

  if (filteredCookies) {
    headers.set("Cookie", filteredCookies);
  } else {
    headers.delete("Cookie"); // Supprime entièrement l'en-tête Cookie si tous les cookies ont été filtrés
  }

  // Évite les conflits d'en-tête Host à l'origine
  headers.delete("host");

  // Reconstruit la requête pour l'origine
  const originReq = new Request(target, {
    method: request.method,
    headers,
    body: request.body
  });

  // Contourne le cache pour garantir que les hits de mesure ne sont jamais mis en cache
  const co = new CacheOverride("pass");

  // Envoie la requête au backend Fastly configuré
  return fetch(originReq, { backend: BACKEND, cacheOverride: co });

}
```

Important :

* Remplacez `s1234.commander4.com` par le véritable endpoint de votre ID de workspace/site.
* Conservez le même `préfixe` que le chemin que vous réservez sur le domaine client (exemple : `/mypath`).
* N'ajoutez PAS de slash final à la fin du chemin dans les URL côté client.

**Étape 6 : déployez**

Déployez le service Compute :

```
npm run deploy
```

**Étape 7 : testez**

Après le déploiement, Fastly fournit un domaine temporaire pour les tests, par exemple :

```
https://plainly-rested-bison.edgecompute.app/mypath/healthy
```

Il doit renvoyer :

```
ok
```

**Liaison de production (domaine client)**

À ce stade, le service Compute s'exécute sur un domaine de test fourni par Fastly. Pour passer en production sur le domaine client (exemple : `https://example.com/mypath/`), vous devez encore lier le service au domaine de production et vous assurer que TLS est en place.

Cela implique généralement, selon la configuration du client :

* Ajouter le domaine client au service Fastly et configurer TLS pour celui-ci (managed TLS ou certificat client).
* Créer l'enregistrement DNS requis (souvent un CNAME) afin que `example.com` pointe vers Fastly.
* S'assurer que le service Compute est celui qui reçoit les requêtes pour le chemin choisi (exemple : `/mypath*`) sur ce domaine.

Comme les étapes exactes dépendent des produits Fastly activés sur le compte et de la manière dont le client gère TLS et DNS, considérez ceci comme une étape bêta et contactez le support si vous avez besoin des commandes exactes pour votre configuration spécifique.
{% endtab %}
{% endtabs %}

***

## Étape 3 : mettez à jour les scripts dans votre système de tag management ou votre site web

Remplacez les URL des scripts fournisseurs par les nouveaux **chemins first-party**.

Exemples :

### Google

```html
<!-- Au lieu de -->
<script async src="https://www.googletagmanager.com/gtag/js?id=G-12345"></script>

<!-- Utilisez -->
<script async src="/mypath/"></script>
```

### Meta (Facebook Pixel)

```html
<!-- Au lieu de -->
<script src="https://connect.facebook.net/en_US/fbevents.js"></script>

<!-- Utilisez (chemin obfusqué fourni dans l'interface Commanders Act) -->
<script src="/mypath/js/f4558899203.js"></script>
```

### Snapchat

```html
<script src="/mypath/js/a82b99df732.js"></script>
```

### Bing (UET)

```html
<script src="/mypath/js/c77ac91be11.js"></script>
```

Chaque nom de fichier obfusqué est généré automatiquement et disponible dans le **interface d'hébergement first-party de Commanders Act**.

### OneTag

Vous pouvez modifier manuellement le domaine de votre configuration cact() avec la `collectionDomain` propriété Exemple :

```javascript
cact(..., {collectionDomain: "www.youdomain.com/mypath"});
```

Avertissement : n'ajoutez PAS un `/` à la fin du chemin

***

## Étape 4 : vérifiez la configuration

* Pour le chemin global, vérifiez l'endpoint de santé :
  * `https://example.com/mypath/healthy` → doit renvoyer `ok`
* Utilisez les DevTools du navigateur pour vérifier que :
  * les scripts Google sont chargés depuis `/mypath/`
  * les autres scripts fournisseurs sont chargés depuis `/mypath/js/{obfuscated}.js`
  * Les requêtes sont effectuées vers votre **domaine first-party**.
* Assurez-vous que les événements apparaissent dans les dashboards partenaires respectifs (Google Analytics, Facebook Events Manager, etc.).

***

## Avantages

* **Durabilité**: le tracking continue de fonctionner même avec Safari ITP et les restrictions third-party cookie.
* **Résilience**: servir les scripts depuis votre domaine avec des noms de fichier obfusqués rend l'interférence des règles de blocage plus difficile.
* **Configuration centralisée**: un seul chemin (`/mypath`) gère tous les fournisseurs.
* **Pérenne**: s'adapte au privacy sandbox et aux prochaines restrictions des navigateurs.
*

## Configurez la collecte de données first party pour les fonctionnalités Commanders Act (via Gateway)

Ce chapitre explique comment acheminer la collecte de données Commanders Act via votre **chemin de gateway first party** (par exemple `/mypath`) pour les principales fonctionnalités Commanders Act.

Remarques importantes :

* Le gateway path montré dans les exemples (`/mypath`) n'est qu'un exemple. Les clients choisissent leur propre path lors de la configuration du gateway dans leur outil CDN ou edge (Cloudflare, Akamai, etc.).
* Tous les exemples ci-dessous supposent que votre gateway est en bon état de fonctionnement : `https://example.com/mypath/healthy` renvoie `ok`.

***

### 1. Destinations server-side via le gateway (exemple : Meta Facebook CAPI)

Le tracking server-side Commanders Act repose sur **oneTag** tags. En général, vous aurez un oneTag par événement que vous souhaitez collecter, par exemple :

* `page_view`
* `add_to_cart`
* `purchase`

Pour acheminer ces événements oneTag via le gateway, vous devez mettre à jour la **configuration du tag oneTag** afin que la `cact()` configuration utilise votre domaine et votre chemin de collecte first party.

Dans votre tag oneTag (ou dans le snippet partagé utilisé par vos tags oneTag), définissez `collectionDomain`:

```javascript
cact(..., { collectionDomain: "www.yourdomain.com/mypath" });
```

Notes :

* Remplacez `www.yourdomain.com/mypath` avec votre propre domaine et le path que vous avez configuré dans votre gateway.
* N'ajoutez PAS de suffixe `/` à la fin du chemin.
* Une fois cela défini, tous les événements oneTag (page\_view, add\_to\_cart, purchase, etc.) seront collectés via votre path de gateway first party.

***

### 2. Collecte CDP, Campaign Analytics et CMP via le gateway

*(Data Activation, Campaign Analytics, statistiques CMP et preuve de consentement)*

Ces trois fonctionnalités reposent sur le même mécanisme de routage. Pour envoyer leurs données via le gateway, vous devez définir la variable **`tC.clientCollectDns`** soit :

* directement dans chaque tag concerné, **ou**
* dans un **tag de configuration globale** qui s'exécute avant tous les tags Commanders Act (recommandé).

Exemple :

```javascript
tC.clientCollectDns = "www.yourdomain.com/mypath";
```

Comportement :

* Dès que `tC.clientCollectDns` est définie, la collecte pour **Data Activation, Campaign Analytics et le tracking lié à CMP** sera effectuée via le gateway.
* `mypath` n'est qu'un exemple. Les clients peuvent utiliser n'importe quel path qu'ils ont configuré dans leur configuration de gateway.

Options d'implémentation :

* **Option A (simple) :** ajoutez la ligne directement dans le tag Data Activation / Campaign Analytics / CMP.
* **Option B (recommandée) :** ajoutez-la dans un tag de configuration globale qui s'exécute avant tous les tags Commanders Act.

***

### Liste de vérification

Après avoir appliqué les modifications ci-dessus, vérifiez :

* L'endpoint de santé du gateway : `https://example.com/mypath/healthy` renvoie `ok`.
* Dans les DevTools du navigateur (onglet Network), les requêtes de collecte Commanders Act vont vers votre domaine et path first party (par exemple `https://example.com/mypath/...`).
* Les événements et les données apparaissent comme prévu dans :
  * les dashboards des destinations server-side (exemple : Meta Events Manager pour CAPI)
  * flows Data Activation
  * les rapports de statistiques CMP et de preuve de consentement (le cas échéant)
  * les rapports Campaign Analytics


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://doc.commandersact.com/fr/developpeurs/commanders-tag-gateway.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.