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

> Migrez votre connexion de fédération SAML existante d’un domaine personnalisé Auth0 hérité vers un nouveau domaine personnalisé Auth0, afin de permettre à vos tenants de tirer parti des capacités de Multiple Custom Domain (MCD).

# Migration SAML pour les domaines personnalisés

export const AuthCodeGroup = ({children, dropdown}) => {
  const [processedChildren, setProcessedChildren] = useState(children);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      unsubscribe = window.autorun(() => {
        const processChildren = node => {
          if (typeof node === "string") {
            let processedNode = node;
            for (const [key, value] of window.rootStore.variableStore.values.entries()) {
              const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
              processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value);
            }
            return processedNode;
          } else if (Array.isArray(node)) {
            return node.map(processChildren);
          } else if (node && node.props && node.props.children) {
            return {
              ...node,
              props: {
                ...node.props,
                children: processChildren(node.props.children)
              }
            };
          }
          return node;
        };
        setProcessedChildren(processChildren(children));
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  return <CodeGroup dropdown={dropdown}>{processedChildren}</CodeGroup>;
};

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASQUÉ*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

Migrez votre connexion de fédération SAML existante d’un domaine personnalisé Auth0 hérité vers un nouveau domaine personnalisé, afin de permettre à vos tenants de tirer parti des capacités Multiple Custom Domain (MCD).

Les fournisseurs d’identité externes (IdP) sont souvent codés en dur pour utiliser votre ancien domaine, ce qui vous oblige à déployer un proxy inverse intelligent qui intercepte la réponse SAML envoyée à votre ancien domaine et la redirige de façon sécurisée vers un nouveau domaine personnalisé.

Cela assure une migration fluide pour les utilisateurs fédérés, vous permettant d’utiliser immédiatement votre nouveau domaine sans avoir à attendre les mises à jour de configuration obligatoires de votre IdP.

<div id="prerequisites">
  ## Prérequis
</div>

Ce processus exige une configuration avec Terraform pour mettre en place les composants Auth0 et le déploiement d’un Cloudflare Worker pour la logique de proxy.

Avant d’entamer votre migration, consultez les exigences ci-dessous :

* Un tenant avec un plan Enterprise et MCD activé.
* Deux domaines personnalisés vérifiés configurés dans votre tenant Auth0 :
  1. **Ancien domaine hérité** (pour le proxy)
  2. **Nouveau domaine cible** (pour l’application)
* Terraform CLI et `Node.js/npm` installés.
* Un compte Cloudflare avec accès au domaine qui héberge vos domaines personnalisés.

<div id="how-it-works">
  ## Fonctionnement
</div>

Cette stratégie de migration utilise un proxy inverse intelligent pour faire la transition entre votre ancien domaine personnalisé et votre nouveau domaine. Ce proxy est déployé sur l’ancien domaine afin d’intercepter la réponse d’authentification SAML envoyée par votre fournisseur d’identité (IdP) externe.

Cela est nécessaire, car la configuration de l’IdP est codée en dur pour le endpoint de votre ancien domaine. Le proxy modifie les champs de contrôle de la charge utile SAML (comme `Destination` et `Recipient`) afin qu’ils correspondent correctement au nouveau domaine personnalisé.

Enfin, le proxy transmet cette charge utile corrigée au endpoint de connexion du nouveau domaine. Cela permet un basculement sans interruption vers votre nouveau domaine, sans nécessiter de changements de configuration manuels de la part de vos partenaires IdP.

<div id="setup-and-configuration">
  ## Préparation et configuration
</div>

Pour préparer et configurer votre migration :

1. Clonez le dépôt de migration :

```bash theme={null}
git clone https://github.com/abbaspour/auth0-mcd-federation-migration.git
cd auth0-mcd-federation-migration
```

2. Installez les dépendances :

```bash theme={null}
npm install
```

3. Créez un fichier `terraform.auto.tfvars` dans votre répertoire `tf` avec les identifiants requis et les informations sur le domaine :

```bash theme={null}
# Variables du fournisseur de services (SP) Auth0
auth0_domain = "your-sp-tenant.auth0.com"
auth0_existing_custom_domain = "oldfed.example.com"
auth0_new_custom_domain = "id.example2.com"
auth0_tf_client_id = "your-sp-client-id"
auth0_tf_client_secret = "your-sp-client-secret"

# Variables du fournisseur d'identité (IDP) Auth0
auth0_idp_domain = "your-idp-tenant.auth0.com"
auth0_idp_tf_client_id = "your-idp-client-id"
auth0_idp_tf_client_secret = "your-idp-client-secret"

# Variables Cloudflare
cloudflare_api_key = "your-cloudflare-api-key"
cloudflare_email = "your-cloudflare-email"
cloudflare_zone_id = "your-cloudflare-zone-id"
```

4. Initialisez et appliquez Terraform :

```bash theme={null}
cd tf
terraform init
terraform apply
```

Cela crée l’application et la connexion SAML nécessaires, configure le DNS dans Cloudflare et prépare les variables d’environnement pour le worker.

<div id="deploy-the-cloudflare-worker">
  ### Déployer le Cloudflare Worker
</div>

Ce proxy gère l’interception de la réponse SAML et la logique de redirection. Pour le déployer :

1. Déployez le proxy Cloudflare :

```bash theme={null}
cd ..
npx wrangler deploy
```

2. Le worker reçoit automatiquement les variables d’environnement requises (comme `AUTH0_EDGE_LOCATION` et `NEW_SP_DOMAIN`) à partir de la sortie de Terraform.

<div id="temporarily-update-saml-connection-parameters">
  ### Mettre temporairement à jour les paramètres de la connexion SAML
</div>

Votre ancien domaine reçoit la réponse SAML avant qu’elle ne soit renvoyée au nouveau domaine. Par conséquent, les paramètres de validation attendus de la connexion SAML doivent temporairement pointer vers l’URL de rappel de l’ancien domaine afin d’éviter les erreurs de non-correspondance.

1. Obtenez un jeton d’accès à la Management API pour le tenant de votre fournisseur de services, avec les portées `read:connections` et `update:connections` :

   ```bash theme={null}
   cd bin/
   export access_token='<sp-tenant-management-api-token>'
   ```

2. Mettez à jour l’URL de destination :

   ```bash theme={null}
   ./sp-set-destination-url.sh -i <saml-connection-id> -d https://oldfed.example.com/login/callback
   ```

3. Mettez à jour l’URL du destinataire :

   ```bash theme={null}
   ./sp-set-recipient-url.sh -i <saml-connection-id> -r https://oldfed.example.com/login/callback
   ```