> ## 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.

> Découvrez comment connecter votre application à Active Directory Federation Services (ADFS) grâce à des connexions d’entreprise.

# Connectez votre application à ADFS

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>;
};

Pour connecter votre application à Active Directory Federation Services (ADFS) de Microsoft, vous devez fournir les renseignements suivants à votre administrateur ADFS :

* Identificateur de realm : `urn:auth0:{yourTenant}`
* Endpoint : `https://{yourDomain}/login/callback` ou `https://<YOUR CUSTOM DOMAIN>/login/callback`, si vous utilisez un [domaine personnalisé](/docs/fr-ca/customize/custom-domains).

<Card title="Métadonnées de fédération">
  Le fichier Federation Metadata contient des renseignements sur les certificats du serveur ADFS. Si l’endpoint Federation Metadata (`/FederationMetadata/2007-06/FederationMetadata.xml`) est activé dans ADFS, Auth0 peut vérifier périodiquement (une fois par jour) si la configuration a changé, par exemple si un nouveau certificat de signature a été ajouté en prévision d’un remplacement. Pour cette raison, il est préférable d’activer l’endpoint Federation Metadata plutôt que de fournir un fichier de métadonnées autonome. Si vous fournissez un fichier de métadonnées autonome, nous vous en informerons par courriel lorsque les certificats approcheront de leur date d’expiration.

  Auth0 applique une limite de taille de 128 Ko aux métadonnées de fédération et renvoie l’erreur `Federation metadata document exceeds the maximum allowed size of 128 KB` lorsque cette limite est dépassée.
</Card>

Vous pouvez utiliser un script pour configurer la connexion ou effectuer la configuration manuellement.

<div id="scripted-setup">
  ## Configuration par script
</div>

Exécutez les deux commandes suivantes dans la fenêtre Windows PowerShell.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Vous devez exécuter ce script avec des privilèges d’administrateur sur votre système.
</Callout>

```powershell wrap lines theme={null}
(new-object Net.WebClient -property @{Encoding = [Text.Encoding]::UTF8}).DownloadString("https://raw.github.com/auth0/adfs-auth0/master/adfs.ps1") | iex
```

export const codeExample1 = `AddRelyingParty "urn:auth0:{yourTenant}" "https://{yourDomain}/login/callback"`;

<AuthCodeBlock children={codeExample1} language="powershell" />

Pour une intégration automatisée, ce script utilise le [ADFS PowerShell SnapIn](http://technet.microsoft.com/en-us/library/adfs2-powershell-basics.aspx) pour créer et configurer un **<Tooltip tip="Relying Party : entité (comme un service ou une application) qui dépend d’un fournisseur d’identité tiers pour authentifier un utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Relying+Party">Relying Party</Tooltip>** qui émettra, pour l’utilisateur authentifié, les claims suivants : **email**, **upn**, **given name** et **surname**.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Si vous utilisez la fonctionnalité [domaines personnalisés](/docs/fr-ca/customize/custom-domains), vous devrez remplacer la valeur `$webAppEndpoint` par `https://<YOUR CUSTOM DOMAIN>/login/callback`.
</Callout>

Le script crée le Relying Party Trust dans ADFS, comme suit :

export const codeExample2 = `$realm = "urn:auth0:{yourTenant}";
$webAppEndpoint = "https://{yourDomain}/login/callback";
Add-PSSnapin Microsoft.Adfs.Powershell
Add-ADFSRelyingPartyTrust -Name $realm -Identifier $realm -WSFedEndpoint $webAppEndpoint
$rp = Get-ADFSRelyingPartyTrust -Name $realm`;

<AuthCodeBlock children={codeExample2} language="powershell" />

Le script crée aussi des rules pour renvoyer les attributs les plus courants, comme le courriel, l’UPN, le prénom ou le nom de famille :

```powershell lines theme={null}
$rules = @'
@RuleName = "Store: ActiveDirectory -> Mail (ldap attribute: mail), Name (ldap attribute: displayName), Name ID (ldap attribute: userPrincipalName), GivenName (ldap attribute: givenName), Surname (ldap attribute: sn)"
c:[Type == "http://schemas.microsoft.com/ws/2008/06/identity/claims/windowsaccountname", Issuer == "AD AUTHORITY"]
=> issue(store = "Active Directory",
    types = ("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress",
             "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name",
             "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier",
             "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname",
             "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/surname"), query = ";mail,displayName,userPrincipalName,givenName,sn;{0}", param = c.Value);
'@
Set-ADFSRelyingPartyTrust –TargetName $realm -IssuanceTransformRules $rules
$rSet = New-ADFSClaimRuleSet –ClaimRule '=> issue(Type = "http://schemas.microsoft.com/authorization/claims/permit", Value = "true");'
Set-ADFSRelyingPartyTrust –TargetName $realm –IssuanceAuthorizationRules $rSet.ClaimRulesString
```

<div id="manual-setup-part-1-add-a-relying-party-trust">
  ## Configuration manuelle, partie 1 : ajouter un Relying Party Trust
</div>

1. Ouvrez la console de gestion ADFS.
2. Dans le volet droit de la console, cliquez sur **Ajouter un Relying Party Trust**\*
3. Cliquez sur **Démarrer**.
4. Sélectionnez **Saisir manuellement les données relatives à la partie de confiance**, puis cliquez sur **Suivant**.
5. Entrez un nom (par exemple `{yourAppName}`), puis cliquez sur **Suivant**.
6. Conservez la valeur par défaut (`ADFS 2.0 profile`), puis cliquez sur **Suivant**.
7. Conservez la valeur par défaut (`no encryption certificate`), puis cliquez sur **Suivant**.
8. Cochez **Activer la prise en charge de WS-Federation...**, puis entrez cette valeur dans la zone de texte :
   `https://{yourDomain}/login/callback`, ou, si vous utilisez un [domaine personnalisé](/docs/fr-ca/customize/custom-domains), utilisez `https://<YOUR CUSTOM DOMAIN>/login/callback`
9. Cliquez sur **Suivant**.
10. Ajoutez un identificateur de Relying Party Trust avec cette valeur :
    `urn:auth0:{yourTenant}`
11. Cliquez sur **Ajouter**, puis sur **Suivant**.
12. Conservez la valeur par défaut `Permit all users...`, puis cliquez sur **Suivant**.
13. Cliquez sur **Suivant**, puis sur **Fermer**.

<div id="manual-setup-part-2-add-a-claim-issuance-policy-rule">
  ## Configuration manuelle, partie 2 : Ajouter une règle de stratégie d’émission de claims
</div>

1. Si vous utilisez Windows Server 2019, la boîte de dialogue Edit Claim Issuance Policy s’ouvre automatiquement lorsque vous terminez l’assistant Add Relying Party Trust. Si vous utilisez Windows Server 2012 ou 2016, suivez ces étapes :

| Dans Windows Server 2012                                                                                                                                         | Dans Windows Server 2016                                                                                                                                                                                                                          |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Dans le panneau Actions, à droite de la console, repérez le Relying Party Trust que vous venez de créer. En dessous, cliquez sur **Edit Claim Issuance Policy**. | Dans l’arborescence de la console, sous ADFS, cliquez sur **Relying Party Trusts**. À droite de la console, repérez le Relying Party Trust que vous venez de créer. Cliquez dessus avec le bouton droit, puis sur **Edit Claim Issuance Policy**. |

2. Dans la fenêtre Edit Claim Issuance Policy, sous Issuance Transform Rules, cliquez sur **Add Rule...**.
3. Conservez la valeur par défaut `Send LDAP Attributes as Claims`.
4. Donnez à la règle un nom qui décrit ce qu’elle fait.
5. Sous Attribute Store, sélectionnez **Active Directory**.
6. Sélectionnez les mappages suivants sous `Mapping of LDAP attributes to outgoing claim types`, puis cliquez sur **Finish**.

| Attribut LDAP       | Type de claim de sortie |
| ------------------- | ----------------------- |
| E-Mail-Addresses    | E-Mail Address          |
| Display-Name        | Name                    |
| User-Principal-Name | Name ID                 |
| Given-Name          | Given Name              |
| Surname             | Surname                 |

<div id="add-additional-ldap-attributes">
  ### Ajouter des attributs LDAP supplémentaires
</div>

Les mappages des étapes précédentes sont les plus courants, mais si vous avez besoin d’attributs LDAP supplémentaires contenant des renseignements sur l’utilisateur, vous pouvez ajouter d’autres mappages de claims.

1. Si vous avez fermé la fenêtre à l’étape précédente, sélectionnez **Edit Claim Rules** dans le menu contextuel du Relying Party Trust que vous avez créé, puis modifiez la règle.
2. Ajoutez une ligne supplémentaire pour chaque attribut LDAP dont vous avez besoin, en choisissant le nom de l’attribut dans la colonne de gauche et le type de claim voulu dans la colonne de droite.
3. Si le type de claim recherché n’existe pas, vous avez deux options :

   1. Entrez un [nom qualifié par un espace de noms](/docs/fr-ca/secure/tokens/json-web-tokens/create-custom-claims) pour le nouveau claim (par exemple, `http://schemas.xmlsoap.org/ws/2005/05/identity/claims/department`).
   2. Enregistrez un nouveau type de claim (sous **ADFS > Services > Claim Descriptions** dans la console d’administration ADFS), puis utilisez le nom du claim dans le mappage.
      Auth0 utilise la partie nom du type de claim (par exemple `department` dans `http://schemas.xmlsoap.org/ws/2005/05/identity/claims/department`) comme nom d’attribut pour le profil utilisateur.

<div id="next-steps">
  ## Prochaines étapes
</div>

Maintenant que vous disposez d’une connexion fonctionnelle, l’étape suivante consiste à configurer votre application pour l’utiliser. Vous pouvez suivre nos Quickstarts détaillés ou utiliser nos bibliothèques et notre API.

* [Découvrez nos Quickstarts](/docs/fr-ca/quickstarts)
* [Configurez votre application à l’aide de notre formulaire de connexion Lock](/docs/fr-ca/libraries/lock)
* [Configurez votre application à l’aide de la bibliothèque Auth0.js et de votre propre UI](/docs/fr-ca/libraries/auth0js)
* [Utilisez notre Authentication API pour l’authentification](https://auth0.com/docs/api/authentication)