> ## 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 créer des Rules à l’aide d’Auth Dashboard ou de la Management API.

# Créer des Rules

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

<Warning>
  La date de fin de vie (EOL) de Rules et Hooks est fixée au **18 novembre 2026**, et ils ne sont plus disponibles pour les nouveaux tenants créés à compter du **16 octobre 2023**. Les tenants existants ayant des Hooks actifs conserveront l’accès au produit Hooks jusqu’à la fin de vie.

  Nous vous recommandons fortement d’utiliser Actions pour étendre Auth0. Avec Actions, vous avez accès à de riches informations de typage, à de la documentation intégrée et à des packages `npm` publics, et vous pouvez connecter des intégrations externes qui améliorent votre expérience globale en matière d’extensibilité. Pour en savoir plus sur ce qu’offre Actions, consultez [Comprendre le fonctionnement des Auth0 Actions](/docs/fr-ca/customize/actions/actions-overview).

  Pour vous aider dans votre migration, nous offrons des guides qui vous aideront à [passer de Rules à Actions](/docs/fr-ca/customize/actions/migrate/migrate-from-rules-to-actions) et à [passer de Hooks à Actions](/docs/fr-ca/customize/actions/migrate/migrate-from-hooks-to-actions). Nous avons aussi une page dédiée, [Move to Actions](https://auth0.com/platform/extensibility/movetoactions), qui présente des comparaisons de fonctionnalités, [une démo d’Actions](https://www.youtube.com/watch?v=UesFSY1klrI) et d’autres ressources pour vous accompagner dans votre migration.

  Pour en savoir plus sur la dépréciation de Rules et Hooks, consultez notre billet de blogue : [Preparing for Rules and Hooks End of Life](https://auth0.com/blog/preparing-for-rules-and-hooks-end-of-life/).
</Warning>

<Warning>
  Comme nous prévoyons retirer les fonctions Rules et Hooks en 2026, vous ne devriez créer de nouvelles Rules ou de nouveaux Hooks que dans votre environnement de développement, et uniquement pour tester la migration vers Actions.

  Pour savoir comment migrer vos Rules vers Actions, consultez [Passer de Rules à Actions](/docs/fr-ca/customize/actions/migrate/migrate-from-rules-to-actions). Pour savoir comment migrer vos Hooks vers Actions, consultez [Passer de Hooks à Actions](/docs/fr-ca/customize/actions/migrate/migrate-from-hooks-to-actions).
</Warning>

Vous pouvez créer vos propres Rule(s) pour répondre à vos besoins fonctionnels précis. Vous pouvez modifier un modèle de Rule existant ou choisir de partir de zéro à l’aide de l’un de nos exemples. Auth0 fournit un certain nombre de Rules et de modèles de Rule pour vous aider à atteindre vos objectif(s). Pour voir la liste, consultez notre [dépôt de Rules sur GitHub](https://github.com/auth0/rules).

<div id="how-rules-work">
  ## Fonctionnement des Rule
</div>

Les Rule sont des fonctions JavaScript qui s’exécutent lorsqu’un utilisateur s’authentifie auprès de votre application. Elles s’exécutent une fois le processus d’authentification terminé, et vous pouvez les utiliser pour personnaliser et étendre les capacités d’Auth0. Pour des raisons de sécurité, le code de vos Rule s’exécute de façon isolée de celui des autres tenants Auth0 dans un bac à sable. Les Rule s’exécutent aussi pendant le flux de renouvellement du jeton. Pour en savoir plus, consultez [Refresh Tokens](/docs/fr-ca/secure/tokens/refresh-tokens).

Dans Auth0, le flux de transaction d’authentification fonctionne comme suit lorsque vous utilisez des Rule :

<Frame>
  <img src="https://mintcdn.com/translations/Dcx0M11uuptU53TX/docs/images/cdy7uua7fh8z/2gtBtkPChIyguA24x6enx2/ffbb8e21e86920ef9914f6fc126dc1df/flow.png?fit=max&auto=format&n=Dcx0M11uuptU53TX&q=85&s=5fe45045dde25176e6cb531d5a938e8e" alt="Schéma des Rule dans le flux d’authentification" width="2942" height="1062" data-path="docs/images/cdy7uua7fh8z/2gtBtkPChIyguA24x6enx2/ffbb8e21e86920ef9914f6fc126dc1df/flow.png" />
</Frame>

1. Une application lance une requête d’authentification vers Auth0.
2. Auth0 achemine la requête vers un fournisseur d’identité au moyen d’une connexion configurée.
3. L’utilisateur s’authentifie avec succès.
4. Le jeton ID ou le jeton d’accès passe par le pipeline des Rule, puis est envoyé à l’application.

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

Si vous comptez utiliser des variables globales dans votre rule, assurez-vous d’abord de configurer les variables de vos rules. Pour en savoir plus, consultez [Configurer les variables globales pour Rules](/docs/fr-ca/customize/rules/configure-global-variables-for-rules).

<div id="use-the-dashboard">
  ## Utiliser le Dashboard
</div>

1. Accédez à [Dashboard > Auth Pipeline > Rules](https://manage.auth0.com/#/rules) et cliquez sur **Create**.

   <Frame>
     <img src="https://mintcdn.com/translations/pvjQqAy3EB2TK6NP/docs/images/cdy7uua7fh8z/4OiSXzc5fYgPagHdOGbfvj/a589bdf811df66658fe21c509aed610c/Dashboard_-_Auth_Pipeline_-_Rules.png?fit=max&auto=format&n=pvjQqAy3EB2TK6NP&q=85&s=fd0731ae46909908816273b82c2faa9e" alt="Dashboard - Auth Pipeline - Rules " width="1039" height="795" data-path="docs/images/cdy7uua7fh8z/4OiSXzc5fYgPagHdOGbfvj/a589bdf811df66658fe21c509aed610c/Dashboard_-_Auth_Pipeline_-_Rules.png" />
   </Frame>
2. Sélectionnez un modèle de Rule.

   <Frame>
     <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6IydSSjg2oQrdSzErcTYtN/d17348a98c597a74b2989c298764b9e1/dashboard-rules-create_choose-template.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=625ac84ff19fc0d38f2c3db41514ea01" alt="Dashboard - Auth Pipeline - Rules - Template" width="1502" height="1098" data-path="docs/images/cdy7uua7fh8z/6IydSSjg2oQrdSzErcTYtN/d17348a98c597a74b2989c298764b9e1/dashboard-rules-create_choose-template.png" />
   </Frame>
3. Donnez un nom à la rule, modifiez le script selon vos besoins, puis cliquez sur **Save changes**.

   <Frame>
     <img src="https://mintcdn.com/translations/MV7tE-x71x8RWRES/docs/images/cdy7uua7fh8z/5CoC6cnazv2uT1iSq6OGsm/6cb30d9479971be771313da80acc4802/Dashboard_-_Auth_Pipeline_-_Rules_-_Edit_Rule.png?fit=max&auto=format&n=MV7tE-x71x8RWRES&q=85&s=0abaef24f1d52ef0300cb360ee3cfa5d" alt="Dashboard - Auth Pipeline - Rules - Edit Rule" width="1103" height="1018" data-path="docs/images/cdy7uua7fh8z/5CoC6cnazv2uT1iSq6OGsm/6cb30d9479971be771313da80acc4802/Dashboard_-_Auth_Pipeline_-_Rules_-_Edit_Rule.png" />
   </Frame>

<div id="use-the-management-api">
  ## Utiliser la Management API
</div>

Faites une requête `POST` à l’[endpoint Create Rule](https://auth0.com/docs/api/management/v2#!/Rules/post_rules). Assurez-vous de remplacer les valeurs de l’espace réservé `MGMT_API_ACCESS_TOKEN`, `RULE_NAME`, `RULE_SCRIPT`, `RULE_ORDER` et `RULE_ENABLED` par votre <Tooltip tip="Management API : un 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> <Tooltip tip="Management API : un produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Access+Token">jeton d’accès</Tooltip>, le nom de la Rule, le script de la Rule, le numéro d’ordre de la Rule et la valeur d’activation de la Rule, respectivement.

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/api/v2/rules' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'cache-control: no-cache' \
    --header 'content-type: application/json' \
    --data '{ "name": "RULE_NAME", "script": "RULE_SCRIPT" }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/rules");
  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", "{ "name": "RULE_NAME", "script": "RULE_SCRIPT" }", 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/rules"

  	payload := strings.NewReader("{ "name": "RULE_NAME", "script": "RULE_SCRIPT" }")

  	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/rules")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .header("cache-control", "no-cache")
    .body("{ "name": "RULE_NAME", "script": "RULE_SCRIPT" }")
    .asString();
  ```

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

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/api/v2/rules',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN',
      'cache-control': 'no-cache'
    },
    data: {name: 'RULE_NAME', script: 'RULE_SCRIPT'}
  };

  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/rules",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "{ "name": "RULE_NAME", "script": "RULE_SCRIPT" }",
    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 = "{ "name": "RULE_NAME", "script": "RULE_SCRIPT" }"

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

  conn.request("POST", "/{yourDomain}/api/v2/rules", 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/rules")

  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 = "{ "name": "RULE_NAME", "script": "RULE_SCRIPT" }"

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

| Valeur                    | Description                                                                                                                                                                                                                                                                       |
| ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `MGMT_API_ACCESS_TOKEN`   | Jeton d’accès pour la Management API avec le scope `create:rules`.                                                                                                                                                                                                                |
| `RULE_NAME`               | Nom de la Rule que vous souhaitez créer. Le nom de la Rule ne peut contenir que des caractères alphanumériques, des espaces et des traits d’union; il ne peut pas commencer ni se terminer par des espaces ou des traits d’union.                                                 |
| `RULE_SCRIPT`             | Script contenant le code de la Rule. Il doit correspondre à ce que vous saisiriez si vous créiez une nouvelle Rule dans le Dashboard.                                                                                                                                             |
| `RULE_ORDER` (optional)   | Entier qui représente l’ordre dans lequel la Rule doit être exécutée par rapport aux autres Rules. Les Rules associées à un nombre inférieur sont exécutées avant celles associées à un nombre supérieur. Si aucun numéro d’ordre n’est fourni, la Rule sera exécutée en dernier. |
| `RULE_ENABLED` (optional) | Booléen qui indique si la Rule est activée (`true`) ou désactivée (`false`).                                                                                                                                                                                                      |

<Warning>
  Nous exposons des adresses IPv6 dans nos endpoints publics (p. ex., `travel0.us.auth0.com`). Si une request provient d’une machine qui prend en charge IPv6, la propriété `context.request.ip` contiendra une adresse IPv6. Si vous manipulez manuellement des adresses IP, nous vous suggérons d’utiliser la library [ipaddr.js@1.9.0](https://www.npmjs.com/package/ipaddr.js/v/1.9.0).
</Warning>

<div id="manage-rate-limits">
  ## Gérer les limites de débit
</div>

Pour les règles qui appellent les API Auth0, vous devriez toujours gérer les limites de débit en vérifiant l’en-tête `X-RateLimit-Remaining` et en prenant les mesures appropriées lorsque la valeur retournée approche de 0. Vous devriez aussi ajouter une logique pour gérer les cas où vous dépassez les limites de débit établies et recevez le code d’état HTTP 429 (Trop de requêtes) ; dans ce cas, si une nouvelle tentative est nécessaire, il vaut mieux prévoir un délai d’attente progressif afin d’éviter d’entrer dans une boucle infinie de tentatives. Pour en savoir plus sur les limites de débit, consultez [la politique sur les limites de débit des API Auth0](/docs/fr-ca/troubleshoot/customer-support/operational-policies/rate-limit-policy).

<div id="available-modules">
  ## Modules disponibles
</div>

Les Rules s’exécutent dans un bac à sable JavaScript configuré pour une version précise de Node.js.

Le bac à sable est compatible avec toutes les versions du langage JavaScript (et la syntaxe associée) prises en charge par la version de Node.js configurée, ainsi qu’avec un grand nombre de modules Node.js. Pour obtenir la liste des modules de bac à sable pris en charge, consultez [Can I require: Auth0 Extensibility](https://auth0-extensions.github.io/canirequire/).

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

* [Configurer les variables globales pour Rules](/docs/fr-ca/customize/rules/configure-global-variables-for-rules)