> ## 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 à des fournisseurs d’identité SAML à l’aide d’une connexion d’entreprise.

# Connectez votre application aux fournisseurs d’identité SAML

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

Auth0 vous permet de créer des connexions de <Tooltip tip="Security Assertion Markup Language (SAML) : protocole normalisé permettant à deux parties d’échanger des renseignements d’authentification sans mot de passe." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=SAML">SAML</Tooltip> <Tooltip tip="Security Assertion Markup Language (SAML) : protocole normalisé permettant à deux parties d’échanger des renseignements d’authentification sans mot de passe." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Identity+Provider">fournisseur d’identité</Tooltip> (IdP).

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

Avant de commencer :

* [Enregistrez votre application dans Auth0](/docs/fr-ca/get-started/auth0-overview/create-applications).

  * Sélectionnez un **Type d’application** approprié.
  * Ajoutez une **URL de rappel autorisée** de **`{https://yourApp/callback}`**.
  * Assurez-vous que les [types d’autorisation](/docs/fr-ca/get-started/applications/update-grant-types) de votre application incluent les flux appropriés.
* Choisissez le nom de cette connexion d’entreprise

  * L’URL de retour POST (aussi appelée URL du service consommateur d’assertion) devient : `https://{yourDomain}/login/callback?connection={yourConnectionName}`
  * L’ID d’entité devient : `urn:auth0:{yourTenant}:{yourConnectionName}`

<div id="steps">
  ## Étapes
</div>

Pour connecter votre application à un fournisseur d’identité SAML, vous devez :

1. Saisir l’URL de retour POST et l’ID d’entité dans l’IdP (pour savoir comment faire, consultez [les paramètres de configuration du fournisseur d’identité SAML](/docs/fr-ca/authenticate/protocols/saml/saml-identity-provider-configuration-settings)).
2. [Obtenir le certificat de signature auprès de l’IdP](#get-the-signing-certificate-from-the-idp) et [le convertir en Base64](#convert-signing-certificate-to-base64).
3. [Créer une connexion d’entreprise dans Auth0](#create-an-enterprise-connection-in-auth0).
4. [Activer la connexion d’entreprise pour votre application Auth0](#enable-the-enterprise-connection-for-your-auth0-application).
5. [Configurer les mappages](#set-up-mappings) (inutile dans la plupart des cas).
6. [Tester la connexion](#test-the-connection).

<div id="get-the-signing-certificate-from-the-idp">
  ## Obtenir le certificat de signature de l’IdP
</div>

Avec SAML Login, Auth0 agit à titre de fournisseur de services. Vous devrez donc récupérer un certificat de signature X.509 auprès du SAML IdP (au format PEM ou CER), que vous téléverserez ensuite dans Auth0. La façon d’obtenir ce certificat varie; veuillez consulter la documentation de votre IdP si vous avez besoin d’aide supplémentaire.

<div id="convert-signing-certificate-to-base64">
  ### Convertir le certificat de signature en Base64
</div>

Vous pouvez utiliser la <Tooltip tip="Management API : Produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip> ou le <Tooltip tip="Management API : Produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip> pour téléverser le certificat de signature X.509. Si vous utilisez la Management API, vous devez convertir le fichier au format Base64. Pour ce faire, utilisez un [outil simple en ligne](https://www.base64decode.org/) ou exécutez la commande suivante dans Bash : `cat signing-cert.crt | base64`.

<div id="assertion-encryption">
  ## Chiffrement des assertions
</div>

Si vos assertions SAML sont chiffrées, vous devez [configurer des valeurs supplémentaires](/docs/fr-ca/authenticate/protocols/saml/saml-sso-integrations/algorithm-profiles) pour votre connexion afin d’indiquer à Auth0 comment effectuer le déchiffrement.

<div id="create-an-enterprise-connection-in-auth0">
  ## Créer une connexion d’entreprise dans Auth0
</div>

Ensuite, vous devrez créer et configurer une SAML connexion d’entreprise dans Auth0, puis téléverser votre certificat de signature X.509. Cette tâche peut être effectuée au moyen du Dashboard d’Auth0 ou de la Management API.

<div id="create-an-enterprise-connection-using-the-dashboard">
  ### Créer une connexion d’entreprise à l’aide du Dashboard
</div>

1. Accédez à [Auth0 Dashboard > Authentication > Enterprise](https://manage.auth0.com/#/connections/enterprise), repérez **SAML**, puis sélectionnez son `+`.

   <Frame>
     <img src="https://mintcdn.com/translations/eVsQcTnbClN-oB7d/docs/images/cdy7uua7fh8z/1fSTcrZpkgkPR64NnI1lr8/b3454e60a4463e99353603fd11a71983/Enterprise_Connections_-_EN.png?fit=max&auto=format&n=eVsQcTnbClN-oB7d&q=85&s=d70364390d8c16ca8efe20e3e1795db4" alt="Dashboard - Connexions - Enterprise" width="600" height="561" data-path="docs/images/cdy7uua7fh8z/1fSTcrZpkgkPR64NnI1lr8/b3454e60a4463e99353603fd11a71983/Enterprise_Connections_-_EN.png" />
   </Frame>
2. Entrez les détails de votre connexion, puis sélectionnez **Créer :**

| Champ                                           | Description                                                                                                                                                                                                                          |
| ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Nom de la connexion**                         | Identifiant logique de votre connexion; il doit être unique dans votre tenant et correspondre au nom utilisé pour configurer l’URL de retour POST et l’Entity ID auprès de l’IdP. Une fois défini, ce nom ne peut plus être modifié. |
| **Sign In URL**                                 | SAML single login URL.                                                                                                                                                                                                               |
| **certificat de signature X.509**               | Certificat de signature (encodé en PEM ou CER) que vous avez récupéré plus tôt dans ce processus auprès de l’IdP.                                                                                                                    |
| **Activer Sign Out**                            | Lorsque cette option est activée, vous pouvez définir une Sign Out URL précise. Sinon, la Sign In URL est utilisée par défaut.                                                                                                       |
| **Sign Out URL** (facultatif)                   | SAML single logout URL.                                                                                                                                                                                                              |
| **Attribut d’ID utilisateur** (facultatif)      | Attribut du jeton SAML qui sera mappé à la propriété `user_id` dans Auth0.                                                                                                                                                           |
| **Mode débogage**                               | Lorsque cette option est activée, des logs plus détaillés sont générés pendant le processus d’authentication.                                                                                                                        |
| **Sign Request**                                | Lorsque cette option est activée, la SAML authentication request est signée. (Veillez à télécharger et à fournir le certificat correspondant afin que l’IdP SAML puisse valider la signature des assertions.)                        |
| **Algorithme de signature de la requête**       | Algorithme qu’Auth0 utilisera pour signer les SAML assertions.                                                                                                                                                                       |
| **Algorithme de condensé de la requête signée** | Algorithme qu’Auth0 utilisera pour le condensé de la requête signée.                                                                                                                                                                 |
| **Liaison de protocole**                        | Liaison HTTP prise en charge par l’IdP.                                                                                                                                                                                              |
| **Modèle de requête** (facultatif)              | Modèle qui met en forme la SAML request.                                                                                                                                                                                             |

<Frame>
  <img src="https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7hvlp8kjva9uFzm5nwsBTQ/4c9f4d01438a3dab6cfb19a5d61d3f13/SAML_Connection_2.png?fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=d1866ce05cbdd547a28f883b5f6018f9" alt="Configurer les paramètres SAML" width="736" height="1488" data-path="docs/images/cdy7uua7fh8z/7hvlp8kjva9uFzm5nwsBTQ/4c9f4d01438a3dab6cfb19a5d61d3f13/SAML_Connection_2.png" />
</Frame>

3\. Dans la vue **Provisioning**, configurez la façon dont les profils utilisateur sont créés et mis à jour dans Auth0.

| Champ                                          | Description                                                                                                                                                                                                                                       |
| ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Sync user profile attributes at each login** | Lorsque cette option est activée, Auth0 synchronise automatiquement les données du profil utilisateur à chaque login, ce qui garantit que les modifications apportées dans la source de la connexion sont automatiquement répercutées dans Auth0. |
| **Sync user profiles using SCIM**              | Lorsque cette option est activée, Auth0 permet de synchroniser les données du profil utilisateur à l’aide de SCIM. Pour en savoir plus, consultez [Configure Inbound SCIM](/docs/fr-ca/authenticate/protocols/scim/configure-inbound-scim).       |

4. Dans la vue **Expérience de connexion**, configurez la façon dont les utilisateurs se connectent avec cette connexion.

| Champ                                      | Description                                                                                                                                                                                                                                                      |
| ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Home Realm Discovery**                   | Compare le domaine de l’adresse courriel d’un utilisateur avec les domaines du fournisseur d’identité fournis. Pour en savoir plus, consultez [Configure Identifier First Authentication](/docs/fr-ca/authenticate/login/auth0-universal-login/identifier-first) |
| **Afficher le bouton de connexion**        | Cette option affiche les choix suivants pour personnaliser le bouton de connexion de votre application.                                                                                                                                                          |
| **Nom d’affichage du bouton** (facultatif) | Texte utilisé pour personnaliser le bouton de connexion de Universal Login. Lorsqu’il est défini, le bouton affiche : « Poursuivre avec \{Nom d’affichage du bouton} ».                                                                                          |
| **URL du logo du bouton** (facultatif)     | URL de l’image utilisée pour personnaliser le bouton de connexion de Universal Login. Lorsqu’elle est définie, le bouton de connexion de Universal Login affiche l’image dans un carré de 20 px sur 20 px.                                                       |

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Les champs facultatifs sont offerts uniquement avec Universal Login. Les clients qui utilisent Classic Login ne verront pas le bouton Add, le Nom d’affichage du bouton ni l’URL du logo du bouton.
</Callout>

5. Si vous avez les permissions administratives appropriées pour terminer l’intégration, cliquez sur **Continue** pour en savoir plus sur les paramètres personnalisés nécessaires pour configurer votre IdP. Sinon, fournissez l’URL indiquée à votre administrateur afin qu’il puisse ajuster les paramètres requis.

<div id="create-an-enterprise-connection-using-the-management-api">
  ### Créer une connexion d’entreprise à l’aide de la Management API
</div>

Vous pouvez aussi utiliser la [Management API](https://auth0.com/docs/api/management/v2) pour créer votre connexion SAML. Pour ce faire, vous pouvez choisir de spécifier manuellement chaque champ de configuration SAML ou de fournir un document de métadonnées SAML contenant les valeurs de configuration.

<div id="create-a-connection-using-specified-values">
  #### Créer une connexion à l’aide des valeurs indiquées
</div>

Effectuez une requête `POST` à l’[endpoint Create a Connection](https://auth0.com/docs/api/management/v2#!/Connections/patch_connections_by_id). Assurez-vous de remplacer les valeurs de l’espace réservé `MGMT_API_ACCESS_TOKEN`, `CONNECTION_NAME`, `SIGN_IN_ENDPOINT_URL`, `SIGN_OUT_ENDPOINT_URL` et `BASE64_SIGNING_CERT` respectivement par votre <Tooltip tip="Jeton d’accès : information d’identification d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisée pour accéder à une API." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Access+Token">jeton d’accès</Tooltip> de la Management API, le nom de la connexion, la Sign In URL, la Sign Out URL et le certificat de signature encodé en Base64 (au format PEM ou CER).

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/connections' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'cache-control: no-cache' \
    --header 'content-type: application/json' \
    --data '{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "signInEndpoint": "SIGN_IN_ENDPOINT_URL", "signOutEndpoint": "SIGN_OUT_ENDPOINT_URL", "signatureAlgorithm": "rsa-sha256", "digestAlgorithm": "sha256", "fieldsMap": {}, "signingCert": "BASE64_SIGNING_CERT" } }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/connections");
  var request = new RestRequest(Method.POST);
  request.AddHeader("content-type", "application/json");
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddHeader("cache-control", "no-cache");
  request.AddParameter("application/json", "{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "signInEndpoint": "SIGN_IN_ENDPOINT_URL", "signOutEndpoint": "SIGN_OUT_ENDPOINT_URL", "signatureAlgorithm": "rsa-sha256", "digestAlgorithm": "sha256", "fieldsMap": {}, "signingCert": "BASE64_SIGNING_CERT" } }", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"strings"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/api/v2/connections"

  	payload := strings.NewReader("{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "signInEndpoint": "SIGN_IN_ENDPOINT_URL", "signOutEndpoint": "SIGN_OUT_ENDPOINT_URL", "signatureAlgorithm": "rsa-sha256", "digestAlgorithm": "sha256", "fieldsMap": {}, "signingCert": "BASE64_SIGNING_CERT" } }")

  	req, _ := http.NewRequest("POST", url, payload)

  	req.Header.Add("content-type", "application/json")
  	req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
  	req.Header.Add("cache-control", "no-cache")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse<String> response = Unirest.post("https://{yourDomain}/api/v2/connections")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .header("cache-control", "no-cache")
    .body("{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "signInEndpoint": "SIGN_IN_ENDPOINT_URL", "signOutEndpoint": "SIGN_OUT_ENDPOINT_URL", "signatureAlgorithm": "rsa-sha256", "digestAlgorithm": "sha256", "fieldsMap": {}, "signingCert": "BASE64_SIGNING_CERT" } }")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/api/v2/connections',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN',
      'cache-control': 'no-cache'
    },
    data: {
      strategy: 'samlp',
      name: 'CONNECTION_NAME',
      options: {
        signInEndpoint: 'SIGN_IN_ENDPOINT_URL',
        signOutEndpoint: 'SIGN_OUT_ENDPOINT_URL',
        signatureAlgorithm: 'rsa-sha256',
        digestAlgorithm: 'sha256',
        fieldsMap: {},
        signingCert: 'BASE64_SIGNING_CERT'
      }
    }
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/api/v2/connections",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "signInEndpoint": "SIGN_IN_ENDPOINT_URL", "signOutEndpoint": "SIGN_OUT_ENDPOINT_URL", "signatureAlgorithm": "rsa-sha256", "digestAlgorithm": "sha256", "fieldsMap": {}, "signingCert": "BASE64_SIGNING_CERT" } }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN",
      "cache-control: no-cache",
      "content-type: application/json"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  payload = "{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "signInEndpoint": "SIGN_IN_ENDPOINT_URL", "signOutEndpoint": "SIGN_OUT_ENDPOINT_URL", "signatureAlgorithm": "rsa-sha256", "digestAlgorithm": "sha256", "fieldsMap": {}, "signingCert": "BASE64_SIGNING_CERT" } }"

  headers = {
      'content-type': "application/json",
      'authorization': "Bearer MGMT_API_ACCESS_TOKEN",
      'cache-control': "no-cache"
      }

  conn.request("POST", "/{yourDomain}/api/v2/connections", payload, headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/api/v2/connections")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Post.new(url)
  request["content-type"] = 'application/json'
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request["cache-control"] = 'no-cache'
  request.body = "{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "signInEndpoint": "SIGN_IN_ENDPOINT_URL", "signOutEndpoint": "SIGN_OUT_ENDPOINT_URL", "signatureAlgorithm": "rsa-sha256", "digestAlgorithm": "sha256", "fieldsMap": {}, "signingCert": "BASE64_SIGNING_CERT" } }"

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

| Valeur                  | Description                                                                                                                  |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `MGMT_API_ACCESS_TOKEN` | [Jeton d’accès pour la Management API](https://auth0.com/docs/api/management/v2/tokens) avec la portée `create:connections`. |
| `CONNECTION_NAME`       | Le nom de la connexion à créer.                                                                                              |
| `SIGN_IN_ENDPONT_URL`   | URL de connexion unique SAML de la connexion à créer.                                                                        |
| `SIGN_OUT_ENDPOINT_URL` | URL de déconnexion unique SAML de la connexion à créer.                                                                      |
| `BASE64_SIGNING_CERT`   | certificat de signature X.509 (encodé en PEM ou CER) que vous avez récupéré auprès de l’IdP.                                 |

Ou, en JSON :

```json lines theme={null}
{
	"strategy": "samlp",
  	"name": "CONNECTION_NAME",
  	"options": {
    	"signInEndpoint": "SIGN_IN_ENDPOINT_URL",
    	"signOutEndpoint": "SIGN_OUT_ENDPOINT_URL",
    	"signatureAlgorithm": "rsa-sha256",
    	"digestAlgorithm": "sha256",
    	"fieldsMap": {
     		...
    	},
    	"signingCert": "BASE64_SIGNING_CERT"
  	}
}
```

<div id="create-a-connection-using-saml-metadata">
  #### Créer une connexion à l’aide d’un document de métadonnées SAML
</div>

Au lieu de renseigner chaque champ de configuration SAML, vous pouvez fournir un document de métadonnées SAML qui contient les valeurs de configuration. Lorsque vous indiquez un document de métadonnées SAML, vous pouvez fournir soit le contenu XML du document (`metadataXml`), soit l’URL du document (`metadataUrl`). Lorsque vous fournissez l’URL, le contenu n’est téléchargé qu’une seule fois ; la connexion ne se reconfigurera pas automatiquement si le contenu à cette URL change par la suite.

Pour les connexions SAML, Auth0 impose une limite de taille de 4 Mo aux documents de découverte de métadonnées et renvoie l’erreur `SAML metadata document exceeded the maximum allowed size of 4 MB` lorsque cette limite est dépassée.

<div id="provide-metadata-document-content">
  ##### Fournir le contenu du document de métadonnées
</div>

Utilisez l’option `metadataXml` pour fournir le contenu du document de métadonnées :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/connections' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'cache-control: no-cache' \
    --header 'content-type: application/json' \
    --data '{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataXml": "<EntityDescriptor entityID='''urn:saml-idp''' xmlns='''urn:oasis:names:tc:SAML:2.0:metadata'''>...</EntityDescriptor>" } }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/connections");
  var request = new RestRequest(Method.POST);
  request.AddHeader("content-type", "application/json");
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddHeader("cache-control", "no-cache");
  request.AddParameter("application/json", "{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataXml": "<EntityDescriptor entityID='urn:saml-idp' xmlns='urn:oasis:names:tc:SAML:2.0:metadata'>...</EntityDescriptor>" } }", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"strings"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/api/v2/connections"

  	payload := strings.NewReader("{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataXml": "<EntityDescriptor entityID='urn:saml-idp' xmlns='urn:oasis:names:tc:SAML:2.0:metadata'>...</EntityDescriptor>" } }")

  	req, _ := http.NewRequest("POST", url, payload)

  	req.Header.Add("content-type", "application/json")
  	req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
  	req.Header.Add("cache-control", "no-cache")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse<String> response = Unirest.post("https://{yourDomain}/api/v2/connections")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .header("cache-control", "no-cache")
    .body("{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataXml": "<EntityDescriptor entityID='urn:saml-idp' xmlns='urn:oasis:names:tc:SAML:2.0:metadata'>...</EntityDescriptor>" } }")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/api/v2/connections',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN',
      'cache-control': 'no-cache'
    },
    data: {
      strategy: 'samlp',
      name: 'CONNECTION_NAME',
      options: {
        metadataXml: '<EntityDescriptor entityID='urn:saml-idp' xmlns='urn:oasis:names:tc:SAML:2.0:metadata'>...</EntityDescriptor>'
      }
    }
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/api/v2/connections",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataXml": "<EntityDescriptor entityID='urn:saml-idp' xmlns='urn:oasis:names:tc:SAML:2.0:metadata'>...</EntityDescriptor>" } }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN",
      "cache-control: no-cache",
      "content-type: application/json"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  iimport http.client

  conn = http.client.HTTPSConnection("")

  payload = "{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataXml": "<EntityDescriptor entityID='urn:saml-idp' xmlns='urn:oasis:names:tc:SAML:2.0:metadata'>...</EntityDescriptor>" } }"

  headers = {
      'content-type': "application/json",
      'authorization': "Bearer MGMT_API_ACCESS_TOKEN",
      'cache-control': "no-cache"
      }

  conn.request("POST", "/{yourDomain}/api/v2/connections", payload, headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/api/v2/connections")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Post.new(url)
  request["content-type"] = 'application/json'
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request["cache-control"] = 'no-cache'
  request.body = "{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataXml": "<EntityDescriptor entityID='urn:saml-idp' xmlns='urn:oasis:names:tc:SAML:2.0:metadata'>...</EntityDescriptor>" } }"

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

<div id="provide-a-metadata-document-url">
  ##### Fournissez l’URL du document de métadonnées
</div>

Utilisez l’option `metadataUrl` pour indiquer l’URL du document :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/connections' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'cache-control: no-cache' \
    --header 'content-type: application/json' \
    --data '{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataUrl": "https://saml-idp/samlp/metadata/uarlU13n63e0feZNJxOCNZ1To3a9H7jX" } }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/connections");
  var request = new RestRequest(Method.POST);
  request.AddHeader("content-type", "application/json");
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddHeader("cache-control", "no-cache");
  request.AddParameter("application/json", "{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataUrl": "https://saml-idp/samlp/metadata/uarlU13n63e0feZNJxOCNZ1To3a9H7jX" } }", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"strings"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/api/v2/connections"

  	payload := strings.NewReader("{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataUrl": "https://saml-idp/samlp/metadata/uarlU13n63e0feZNJxOCNZ1To3a9H7jX" } }")

  	req, _ := http.NewRequest("POST", url, payload)

  	req.Header.Add("content-type", "application/json")
  	req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
  	req.Header.Add("cache-control", "no-cache")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse<String> response = Unirest.post("https://{yourDomain}/api/v2/connections")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .header("cache-control", "no-cache")
    .body("{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataUrl": "https://saml-idp/samlp/metadata/uarlU13n63e0feZNJxOCNZ1To3a9H7jX" } }")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/api/v2/connections',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN',
      'cache-control': 'no-cache'
    },
    data: {
      strategy: 'samlp',
      name: 'CONNECTION_NAME',
      options: {
        metadataUrl: 'https://saml-idp/samlp/metadata/uarlU13n63e0feZNJxOCNZ1To3a9H7jX'
      }
    }
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/api/v2/connections",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataUrl": "https://saml-idp/samlp/metadata/uarlU13n63e0feZNJxOCNZ1To3a9H7jX" } }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN",
      "cache-control: no-cache",
      "content-type: application/json"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  payload = "{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataUrl": "https://saml-idp/samlp/metadata/uarlU13n63e0feZNJxOCNZ1To3a9H7jX" } }"

  headers = {
      'content-type': "application/json",
      'authorization': "Bearer MGMT_API_ACCESS_TOKEN",
      'cache-control': "no-cache"
      }

  conn.request("POST", "/{yourDomain}/api/v2/connections", payload, headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/api/v2/connections")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_PEER

  request = Net::HTTP::Post.new(url)
  request["content-type"] = 'application/json'
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request["cache-control"] = 'no-cache'
  request.body = "{ "strategy": "samlp", "name": "CONNECTION_NAME", "options": { "metadataUrl": "https://saml-idp/samlp/metadata/uarlU13n63e0feZNJxOCNZ1To3a9H7jX" } }"

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

Lorsque vous indiquez l’URL, le contenu n’est téléchargé qu’une seule fois ; la connexion ne se reconfigure pas automatiquement si le contenu à cette URL est modifié ultérieurement.

<div id="refresh-existing-connection-information-with-metadata-url">
  ##### Actualiser les informations d’une connexion existante avec l’URL de métadonnées
</div>

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Ce processus ne fonctionnera que si la connexion a été créée manuellement avec `metadataUrl`.
</Callout>

Si vous avez une mise en œuvre B2B et que vous fédérez vers Auth0 à l’aide de votre propre fournisseur d’identité SAML, vous devrez peut-être actualiser les informations de connexion stockées dans Auth0, comme les changements de certificat de signature, les changements d’URL de point de terminaison ou les nouveaux champs d’assertion. Auth0 le fait automatiquement pour les connexions ADFS, mais pas pour les connexions SAML.

Vous pouvez créer un processus par lots (tâche cron) pour effectuer une actualisation périodique. Le processus peut s’exécuter toutes les quelques semaines et effectuer une requête PATCH vers le point de terminaison `/api/v2/connections/CONNECTION_ID`, en transmettant un corps contenant `{options: {metadataUrl: '$URL'}}`, où `$URL` est la même URL de métadonnées que celle utilisée pour créer la connexion. Vous utilisez l’URL de métadonnées pour créer une nouvelle connexion temporaire, puis comparez les propriétés de l’ancienne et de la nouvelle connexion. Si quelque chose est différent, mettez à jour la nouvelle connexion, puis supprimez la connexion temporaire.

1. Créez une connexion SAML avec `options.metadataUrl`. L’objet de connexion sera rempli avec les informations provenant des métadonnées.
2. Mettez à jour le contenu des métadonnées à l’URL.
3. Envoyez une requête PATCH au point de terminaison `/api/v2/connections/CONNECTION_ID` avec `{options: {metadataUrl: '$URL'}}`. L’objet de connexion est maintenant mis à jour avec le nouveau contenu des métadonnées.

<Warning>
  Si vous utilisez le paramètre `options`, vous remplacez l’objet `options` au complet. Assurez-vous que tous les paramètres sont présents.
</Warning>

<div id="specify-a-custom-entity-id">
  ## Spécifier un ID d’entité personnalisé
</div>

Pour spécifier un ID d’entité personnalisé, utilisez la Management API pour remplacer la valeur par défaut `urn:auth0:YOUR_TENANT:YOUR_CONNECTION_NAME`. Définissez la propriété `connection.options.entityID` lors de la création de la connexion ou en mettant à jour une connexion existante.

L’exemple JSON ci-dessous peut être utilisé pour créer une nouvelle connexion SAML à l’aide de l’URL de métadonnées de l’IdP SAML, tout en spécifiant un ID d’entité personnalisé. L’ID d’entité demeure unique, puisqu’il est créé à partir du nom de la connexion.

```json lines theme={null}
{
  "strategy": "samlp", 
  "name": "{yourConnectionName}", 
  "options": { 
    "metadataUrl": "https://saml-idp/samlp/metadata/uarlU13n63e0feZNJxOCNZ1To3a9H7jX",
    "entityId": "urn:your-custom-sp-name:{yourConnectionName}"
  }
}
```

<div id="enable-the-enterprise-connection-for-your-auth0-application">
  ## Activez la connexion d’entreprise pour votre application Auth0
</div>

Pour utiliser votre nouvelle connexion d’entreprise SAML, vous devez d’abord [activer la connexion](/docs/fr-ca/authenticate/identity-providers/enterprise-identity-providers/enable-enterprise-connections) pour vos applications Auth0.

<div id="set-up-mappings">
  ## Configurer les mappages
</div>

<Warning>
  Si vous configurez une connexion d’entreprise SAML pour un serveur PingFederate non standard, vous **devez** mettre à jour les mappages d’attributs.
</Warning>

Sélectionnez la vue **Mappages**, saisissez les mappages entre les `{}`, puis sélectionnez **Enregistrer**.

<Frame>
  <img src="https://mintcdn.com/translations/3nS3prIggmJG9TUI/docs/images/cdy7uua7fh8z/3matGqveShEDX89p8Bcmwr/df5f37c9fb98447badddb1622f79ad95/2025-02-25_09-35-58.png?fit=max&auto=format&n=3nS3prIggmJG9TUI&q=85&s=9e220fee57ff4e2baa09fcc90bcf9598" alt="Configurer les mappages SAML" width="599" height="472" data-path="docs/images/cdy7uua7fh8z/3matGqveShEDX89p8Bcmwr/df5f37c9fb98447badddb1622f79ad95/2025-02-25_09-35-58.png" />
</Frame>

**Mappages pour les serveurs PingFederate non standard :**

```json lines theme={null}
{
    "user_id": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier",
    "email": "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier"
}
```

**Mappages pour <Tooltip tip="Single Sign-On (SSO) : service qui permet à un utilisateur, après s’être connecté à une application, d’être automatiquement connecté aux autres applications." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=SSO">SSO</Tooltip> Circle**

```json lines theme={null}
{
  "email": "EmailAddress",
  "given_name": "FirstName",
  "family_name": "LastName"
}
```

**Mapper l’une ou l’autre de deux claims à un attribut utilisateur**

```json lines theme={null}
{
  "given_name": [
    "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname",
    "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name"
  ]
}
```

**Comment mapper le Name Identifier à un attribut d’utilisateur**

```json lines theme={null}
{
  "user_id": [
    "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier",
    "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn",
    "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name"
  ]
}
```

<div id="test-the-connection">
  ## Tester la connexion
</div>

Vous êtes maintenant prêt à [tester votre connexion](/docs/fr-ca/authenticate/identity-providers/enterprise-identity-providers/test-enterprise-connections).

<div id="configure-global-token-revocation">
  ## Configurer la révocation globale des jetons
</div>

Ce type de connexion prend en charge un endpoint de révocation globale des jetons, qui permet à un fournisseur d’identité compatible de révoquer les sessions utilisateur Auth0, de révoquer les <Tooltip tip="Refresh Token : jeton utilisé pour obtenir un nouvel access token sans obliger les utilisateurs à se reconnecter." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=refresh+tokens">jetons d’actualisation</Tooltip> et de déclencher le Back-Channel Logout pour les applications qui utilisent un back-channel sécurisé.

Cette fonctionnalité peut être utilisée avec Universal Logout dans Okta Workforce Identity.

Pour en savoir plus et obtenir les instructions de configuration, consultez [Universal Logout](/docs/fr-ca/authenticate/login/logout/universal-logout).

<div id="learn-more">
  ## En savoir plus
</div>

* [Universal Logout](/docs/fr-ca/authenticate/login/logout/universal-logout)