> 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ée** 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 n’est **pas limité à 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 d’implémenter Google Tag Gateway, vous êtes au bon endroit.\
Si votre objectif est de construire une architecture de tracking First-party durable et indépendante 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é.
* 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**, 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 avantages de toute approche gateway, **Commanders Gateway** apporte des avantages uniques :

* Pas 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, rendant leur détection par les listes de blocage beaucoup plus difficile.
* Avec le même chemin simple, vous pouvez également activer d’autres **fonctionnalités d’hébergement et de tracking First-party** telles que : l’hébergement de vos conteneurs de tag management, le suivi 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 **pérenne** face aux futures restrictions du navigateur.

***

## Aperçu

**Commanders Gateway** vous permet de déployer des tags marketing et de mesure à l’aide de 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/` à l’aide de **noms de fichiers obfusqués**.
* Toutes les requêtes de mesure sont relayées via votre domaine avant d’être transmises aux endpoints des partenaires concernés.

***

## 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/`.
* **Autres scripts des 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 Commanders Act First-party Hosting**.

**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 des cookies à l’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 Worker fourni dans ce guide** (voir l’onglet 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 des cookies avant transmission aux partenaires

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

Par exemple, lors du transfert des requêtes de mesure vers Google, le gateway peut être configuré pour **n’inclure que 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 tag management (Commanders Act, Google Tag Manager ou équivalent).
* Un CDN ou un équilibreur de charge (Cloudflare, Akamai, Fastly, Nginx, etc.) capable de transmettre des requêtes vers des endpoints externes.

***

## Étape 1 : Choisissez le chemin de diffusion du tag

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 : Routage du trafic

{% tabs %}
{% tab title="Cloudflare Enterprise" %}
Lorsque vous utilisez Cloudflare Enterprise, nous recommandons d’utiliser un **Cloudflare Worker** pour proxyfier tout le trafic provenant du 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 de router le chemin avec les règles d’origine Cloudflare, car le Worker offre 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éez 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"; // Chemin d’exemple, remplacez-le par le chemin que vous choisissez à l’étape précédente
const sid = "12345"; // ID d’espace de travail d’exemple (aka ID du site), remplacez-le par votre propre ID

// Liste des noms de cookie 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 d’espace de travail / de 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("Not Found", { 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 également filtrer les cookies sensibles ou techniques avant de transmettre la requête à Commanders Gateway.

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

1. Dans Cloudflare, ouvrez les paramètres de votre domaine.
2. Accédez à **Workers Routes**.
3. Ajoutez une nouvelle route avec :
   * **Motif 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érifiez la configuration**

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

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

Cela devrait renvoyer :

```
ok
```

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

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

Cela devrait également renvoyer :

```
ok
```

{% endtab %}

{% tab title="Cloudflare Free" %}
Lorsque vous utilisez Cloudflare Free, la configuration repose sur un **Worker simple** qui proxyfie tout le trafic provenant du chemin choisi (par ex. `/mypath`) vers l’infrastructure Commanders Gateway.

**Étape 1 : Créez 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"; // Chemin d’exemple, remplacez-le par le chemin que vous choisissez à l’étape précédente
const sid = "12345"; // ID d’espace de travail d’exemple (aka ID du site), remplacez-le par votre propre ID

// Liste des noms de cookie 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 d’espace de travail / de 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("Not Found", { status: 404 }); // Renvoyer 404 si le chemin de la requête ne correspond pas au prefix
}
```

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 : Liez le Worker au chemin**

1. Dans Cloudflare, ouvrez les paramètres de votre domaine.
2. Accédez à **Workers Routes**.
3. Ajoutez une nouvelle route avec :
   * **Motif 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" %}
La prise en charge de Commanders Gateway par Akamai est actuellement en **bêta**. Si vous avez une question ou un problème avec votre configuration, contactez le support
{% endhint %}

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

1. Créez une nouvelle version de votre configuration de diffusion dans **Property Manager**.
2. Sous la **Property Configuration Settings** section, ajoutez une nouvelle Rule :
   * Nommez-la : *Route measurement*
3. Ajoutez un nouveau **Match**:
   * Type de Match : `Path`
   * Condition : *est l’un des*
   * Valeur : `/mypath/*`
4. Ajoutez un nouveau **Comportement**:
   * Sélectionnez *Standard Property Behavior* et choisissez **Origin Server** comme comportement.
   * Définissez **Origin Server Hostname** à `s1234.commander4.com.`
   * Définissez **Forward Host Header** à *Origin Hostname*.
5. Enregistrez la nouvelle règle et déployez vos modifications.
   * ⚠️ Testez la règle de redirection dans votre **environnement de préproduction** avant le déploiement 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 section **Variables de la propriété** 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) sous Paramètres de configuration de la propriété.
3. Ajoutez deux nouveaux **Définir la variable** comportements (un par variable) :

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

4. Ajoutez deux nouveaux **Modifier l’en-tête de 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` → devrait afficher `ok`.
   * Testez les en-têtes de géolocalisation : `https://example.com/mypath/?validate_geo=healthy` → devrait également afficher `ok`.
     {% endtab %}

{% tab title="Fastly" %}
{% hint style="warning" %}
La prise en charge de Commanders Gateway par Fastly est actuellement en **bêta**. Les étapes ci-dessous sont destinées aux utilisateurs techniques familiers 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 %}

Avec Fastly, la configuration diffère de Cloudflare. Vous déployez un **service Compute** (Wasm) et le configurez principalement via l’ **API et le CLI Fastly** depuis un terminal.

**Prérequis**

1. Créez un jeton API dans l’interface Fastly (les périmètres doivent autoriser Compute, services, backends et déploiements).
2. Exportez le token dans l’environnement de votre 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 **service ID**, par exemple :

```
dyBxiT8wpc2c8ZQg2KRrMN
```

Enregistrez-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 le service ID dans fastly.toml**

Modifiez `fastly.toml` et définissez le service ID :

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

**Étape 4 : Créez le backend (origin de Commanders Gateway)**

Créez un backend qui pointe 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 classique. 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 :

* `prefix` (votre chemin client, exemple : `/mypath`)
* `sid` (votre ID de workspace/site Commanders, 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 gateway que vous avez choisi (p. ex. "/mypath")
const sid = "s123456";                       // TODO : remplacez par votre ID de workspace/site (p. ex. "s1234")
const BACKEND = "commander_gateway";         // Nom du backend Fastly pointant vers sid.commander4.com

const STRIP_PREFIX = true;                   // Si true, supprime le prefix du chemin transmis
const PREPEND_PATH = "/gateway";             // Point d’entrée interne du 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);

  // Ne proxy que les requêtes qui correspondent au prefix configuré
  if (!url.pathname.startsWith(prefix)) {
    return new Response("Not Found", { status: 404 });
  }

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

  // Supprimez éventuellement le prefix client (p. ex. "/mypath") pour que l’origin reçoive "/"
  if (STRIP_PREFIX) {
    fwdPath = fwdPath.slice(prefix.length) || "/";
  }

  // Ajoutez le point d’entrée interne Commanders au début (obligatoire)
  if (PREPEND_PATH) {
    fwdPath = PREPEND_PATH + fwdPath;
  }

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

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

  // Transmettez les informations géographiques lorsqu’elles sont disponibles (optionnel 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 le header Cookie si tous les cookies ont été filtrés
  }

  // Évitez les conflits de header Host à l’origin
  headers.delete("host");

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

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

  // Envoyez 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 `prefix` 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 URLs 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
```

Cela devrait renvoyer :

```
ok
```

**Liaison de production (domaine client)**

À ce stade, le service Compute fonctionne 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 le TLS est en place.

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

* Ajouter le domaine client au service Fastly et configurer le TLS pour celui-ci (managed TLS ou certificat client).
* Créer l’enregistrement DNS requis (souvent un CNAME) pour que `example.com` pointe vers Fastly.
* S’assurer que le service Compute est bien 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 le TLS et le DNS, considérez cela 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 tag management system ou votre site web

Remplacez les URLs des scripts éditeurs par les nouveaux **first-party paths**.

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 Commanders Act First-party Hosting**.

### OneTag

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

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

Attention : n’ajoutez PAS de `/` à la fin du chemin

***

## Étape 4 : Vérifiez la configuration

* Pour le chemin global, vérifiez le 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 éditeurs sont chargés depuis `/mypath/js/{obfuscated}.js`
  * les requêtes sont envoyées à votre **domaine First-party**.
* Assurez-vous que les events apparaissent dans les Dashboard partenaires respectifs (Google Analytics, Facebook Events Manager, etc.).

***

## Avantages

* **Durabilité**: le tracking continue de fonctionner même avec Safari ITP et les restrictions de cookie third-party.
* **Résilience**: Servir les scripts depuis votre domaine avec des noms de fichier obfusqués rend plus difficile l’interférence des règles de blocage.
* **Configuration centralisée**: Un seul chemin (`/mypath`) gère tous les vendors.
* **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 router la collecte de données Commanders Act via votre **first party gateway path** (par exemple `/mypath`) pour les principales fonctionnalités Commanders Act.

Remarques importantes :

* Le gateway path présenté dans les exemples (`/mypath`) n’est qu’un exemple. Les clients choisissent leur propre path lors de la configuration du gateway dans leur CDN ou leur outil edge (Cloudflare, Akamai, etc.).
* Tous les exemples ci-dessous supposent que votre gateway est en bon état : `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 event que vous souhaitez collecter, par exemple :

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

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

Dans votre tag oneTag (ou dans l’extrait 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 chemin configuré dans votre gateway.
* N’ajoutez PAS de trailing `/` à la fin du chemin.
* Une fois cela défini, tous les events oneTag (page\_view, add\_to\_cart, purchase, etc.) seront collectés via votre first party gateway path.

***

### 2. CDP, Campaign Analytics et collecte 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 global** 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é au CMP** se fera via le gateway.
* `mypath` n’est qu’un exemple. Les clients peuvent utiliser n’importe quel path 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é) :** ajoutez-la dans un tag de configuration global qui s’exécute avant tous les tags Commanders Act.

***

### Liste de vérification

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

* Le 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 first party et votre path (par exemple `https://example.com/mypath/...`).
* Les events et données apparaissent comme prévu dans :
  * les Dashboard de destination server-side (exemple : Meta Events Manager pour CAPI)
  * les 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:

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

The question should be specific, self-contained, and written in natural language.
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.