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

> Créez votre premier Action Module Auth0 dans le Dashboard Auth0 en créant le module, en ajoutant des secrets et des dépendances NPM, en publiant une version et en l’utilisant pour envoyer des logs à un service externe.

# Créez votre premier Action Module

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

<h2 id="get-started">
  Pour commencer
</h2>

Suivez le Quickstart pour créer un Action Module et l’utiliser dans une Action afin d’envoyer des logs à un service externe.

<Steps titleSize="h3">
  <Step title="Créer un module d’action">
    Pour utiliser un Action Module dans une Action précise, vous devez d’abord créer l’Action Module, puis l’ajouter ou l’utiliser dans l’Action.

    <Tabs>
      <Tab title="Dashboard">
        1. Accédez à [Auth0 Dashboard > Actions > Library](https://manage.auth0.com/#/actions/library), puis sélectionnez **Modules**.
        2. Sélectionnez **Create Module**.
        3. Entrez un **Name**.
        4. Sélectionnez **Create**.

        <Frame>
          <img src="https://mintlify.s3.us-west-1.amazonaws.com/auth0-automated-translations-update/docs/images/customize/actions/modules/actions-modules-new-module.png" alt="Actions Modules - Nouvel Action Module" />
        </Frame>
      </Tab>

      <Tab title="Management API">
        1. [Obtenez un jeton d’accès de la Management API](/docs/fr-ca/secure/tokens/access-tokens/management-api-access-tokens) avec la permission `create:actions`.
        2. Appelez [Create an Actions Module](/docs/fr-ca/api/management/v2/actions/post-action-module) :

        ```shell theme={null}
        curl -L 'https://{yourDomain}/api/v2/actions/modules' \
          -H 'Content-Type: application/json' \
          -H 'Authorization: Bearer {yourMgmtApiAccessToken}' \
          -d '{
            "name": "logger",
            "code": "module.exports = {};",
            "api_version": "1",
            "publish": false
          }'
        ```

        Auth0 retourne le nouvel Action Module, y compris son `id`, que vous utiliserez pour référencer le module aux étapes suivantes.
      </Tab>

      <Tab title="Auth0 CLI">
        <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
          Les Actions Modules ne sont pas exposés nativement par l’ensemble de commandes `auth0-cli`; utilisez donc [`auth0 api`](https://auth0.github.io/auth0-cli/auth0_api.html) pour appeler directement la Management API. Certains appels nécessitent des permissions supplémentaires — au besoin, exécutez d’abord `auth0 login --scopes create:actions,read:actions,update:actions`.
        </Callout>

        Appelez [Create an Actions Module](/docs/fr-ca/api/management/v2/actions/post-action-module) avec `auth0 api` :

        ```shell theme={null}
        auth0 api post actions/modules --data '{
          "name": "logger",
          "code": "module.exports = {};",
          "api_version": "1",
          "publish": false
        }'
        ```

        Auth0 retourne le nouvel Action Module, y compris son `id`, que vous utiliserez pour référencer le module aux étapes suivantes.
      </Tab>

      <Tab title="Terraform">
        <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
          Consultez la documentation de la ressource [`auth0_action_module`](https://registry.terraform.io/providers/auth0/auth0/latest/docs/resources/action_module) pour en savoir plus.
        </Callout>

        1. Ajoutez la ressource suivante à un fichier `.tf`, en référençant le code du module à partir d’un fichier :

        ```terraform title="action-modules/logger.tf" theme={null}
        resource "auth0_action_module" "logger" {
          name = "logger"
          code = file("${path.module}/action-modules/logger/code.js")
        }
        ```

        2. Créez le fichier de code du module à l’emplacement `action-modules/logger/code.js` :

        ```javascript title="action-modules/logger/code.js" theme={null}
        module.exports = {};
        ```

        3. Exécutez `terraform apply`.

        Vous enrichirez le fichier de code et cette ressource avec des secrets aux étapes suivantes.
      </Tab>

      <Tab title="Auth0 Deploy CLI">
        <Tabs>
          <Tab title="YAML">
            1. Créez le fichier de code du module à l’emplacement `action-modules/logger/code.js` :

            ```javascript title="action-modules/logger/code.js" theme={null}
            module.exports = {};
            ```

            2. Ajoutez une entrée `actionModules` dans `tenant.yaml` :

            ```yaml title="tenant.yaml" theme={null}
            actionModules:
              - name: logger
                code: ./action-modules/logger/code.js
            ```

            3. Déployez la configuration :

            ```shell theme={null}
            a0deploy import -c=config.json --input_file=tenant.yaml
            ```
          </Tab>

          <Tab title="Directory (JSON)">
            1. Créez le fichier de configuration du module à l’emplacement `action-modules/logger.json` :

            ```json title="action-modules/logger.json" theme={null}
            {
              "name": "logger",
              "code": "./action-modules/logger/code.js"
            }
            ```

            2. Créez le fichier de code du module à l’emplacement `action-modules/logger/code.js` :

            ```javascript title="action-modules/logger/code.js" theme={null}
            module.exports = {};
            ```

            3. Déployez la configuration :

            ```shell theme={null}
            a0deploy import -c=config.json --input_file=local.
            ```
          </Tab>
        </Tabs>
      </Tab>
    </Tabs>
  </Step>

  <Step title="Ajouter un secret">
    Chaque module d’action peut contenir des paires clé-valeur secrètes. Utilisez-les pour stocker des renseignements sensibles, comme des clés API, des certificats et des valeurs qui peuvent varier d’un environnement à l’autre.

    <Tabs>
      <Tab title="Dashboard">
        Ensuite, enregistrez l’URL du service externe comme Secret.

        1. Sélectionnez l’icône **<svg style={{ display: 'inline' }} width="20" height="20" viewBox="0 0 24 24" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="sc-kJNqSH"><path fill-rule="evenodd" clip-rule="evenodd" d="M19.573 2.06l1.409 1.42-1.192 1.182L22.65 7.5l-4.756 4.72-2.86-2.838-2.783 2.764a6.196 6.196 0 011.196 3.63 6.172 6.172 0 01-1.832 4.41 6.277 6.277 0 01-8.853-.03l-.007-.008A6.183 6.183 0 011 15.782a6.184 6.184 0 011.831-4.335 6.271 6.271 0 017.987-.696l8.755-8.691zm-9.335 10.798l-.045-.043a4.264 4.264 0 00-2.987-1.182 4.262 4.262 0 00-2.966 1.233A4.184 4.184 0 003 15.8a4.183 4.183 0 001.185 2.95 4.276 4.276 0 006.022.016 4.2 4.2 0 001.24-2.984 4.171 4.171 0 00-1.21-2.924zm6.216-4.885l1.44 1.43L19.811 7.5l-1.44-1.43-1.917 1.903z" fill="inherit" /></svg>** dans la barre latérale gauche de l’éditeur de code.
        2. Sélectionnez **Add Secret**.
        3. Saisissez `SERVICE_URL` dans le champ **Name**.
        4. Saisissez l’URL du service externe dans le champ **Value**.
        5. Sélectionnez **Create**.

        <Frame>
          <img src="https://mintlify.s3.us-west-1.amazonaws.com/auth0-automated-translations-update/docs/images/customize/actions/modules/actions-modules-secret.png" alt="Modules d’action - Secret ajouté" />
        </Frame>

        Auth0 ajoute le Secret à la liste des Secrets du module d’action.
      </Tab>

      <Tab title="Management API">
        Ensuite, enregistrez l’URL du service externe comme Secret. Appelez [Update an Actions Module](/docs/fr-ca/api/management/v2/actions/patch-action-module) avec la permission `update:actions` :

        ```shell theme={null}
        curl -L -X PATCH 'https://{yourDomain}/api/v2/actions/modules/{moduleId}' \
          -H 'Content-Type: application/json' \
          -H 'Authorization: Bearer {yourMgmtApiAccessToken}' \
          -d '{
            "secrets": [
              { "name": "SERVICE_URL", "value": "https://example.com/logs" }
            ]
          }'
        ```

        Chaque appel `PATCH` remplace l’ensemble du tableau `secrets` dans le brouillon du module. Incluez donc tous les Secrets dont le module a besoin, et non seulement celui que vous ajoutez.
      </Tab>

      <Tab title="Auth0 CLI">
        Ensuite, enregistrez l’URL du service externe comme Secret. Appelez [Update an Actions Module](/docs/fr-ca/api/management/v2/actions/patch-action-module) avec `auth0 api` :

        ```shell theme={null}
        auth0 api patch actions/modules/{moduleId} --data '{
          "secrets": [
            { "name": "SERVICE_URL", "value": "https://example.com/logs" }
          ]
        }'
        ```

        Chaque appel remplace l’ensemble du tableau `secrets` dans le brouillon du module; incluez donc tous les Secrets dont le module a besoin, et non seulement celui que vous ajoutez.
      </Tab>

      <Tab title="Terraform">
        Ensuite, enregistrez l’URL du service externe comme Secret à l’aide d’un bloc `secrets` :

        ```terraform title="action-modules/logger.tf" theme={null}
        resource "auth0_action_module" "logger" {
          name = "logger"
          code = file("${path.module}/action-modules/logger/code.js")

          secrets {
            name  = "SERVICE_URL"
            value = "https://example.com/logs"
          }
        }
        ```

        <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
          Nous ne prenons pas en charge la gestion partielle des `secrets`. Chaque `terraform apply` envoie la liste complète des secrets définis sur la ressource.
        </Callout>
      </Tab>

      <Tab title="Auth0 Déployer CLI">
        Ensuite, enregistrez l’URL du service externe comme Secret.

        <Tabs>
          <Tab title="YAML">
            Ajoutez un tableau `secrets` à l’entrée du module dans `tenant.yaml` :

            ```yaml highlight={3-5} title="tenant.yaml" theme={null}
            actionModules:
              - name: logger
                secrets:
                  - name: SERVICE_URL
                    value: ##SERVICE_URL##
                code: ./action-modules/logger/code.js
            ```
          </Tab>

          <Tab title="Directory (JSON)">
            Ajoutez un tableau `secrets` à `action-modules/logger.json` :

            ```json highlight={3-5} title="action-modules/logger.json" theme={null}
            {
              "name": "logger",
              "secrets": [
                { "name": "SERVICE_URL", "value": "##SERVICE_URL##" }
              ],
              "code": "./action-modules/logger/code.js"
            }
            ```
          </Tab>
        </Tabs>

        Le paramètre fictif `##SERVICE_URL##` est résolu par [remplacement de mots-clés](https://github.com/auth0/auth0-deploy-cli/blob/master/docs/keyword-replacement.md) au moment du déploiement, de sorte que la valeur réelle ne se trouve jamais dans votre fichier de configuration.
      </Tab>
    </Tabs>

    **Étape supplémentaire :** Répétez les étapes pour enregistrer un `API_KEY` comme Secret que vous enverrez dans les en-têtes au service externe avec chaque requête.

    <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
      Une fois un Secret créé, Auth0 n’en révèle jamais la valeur. Auth0 chiffre tous les Secrets et les stocke de façon sécurisée.
    </Callout>

    <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
      Chaque **Secret de module d’action** est indépendant des autres **Modules d’action** et des **Secrets des Actions**.
    </Callout>

    <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
      Utilisez les **Secrets** dans le module d’action en saisissant `actions.secrets.[secret_key]`.
    </Callout>
  </Step>

  <Step title="Ajouter de la logique personnalisée">
    Maintenant, ajoutez le code suivant à votre module d’action.

    <Tabs>
      <Tab title="Dashboard">
        Ajoutez le code suivant à votre module d’action :

        ```javascript theme={null}
        module.exports = {
          sendLog: async (code, message) => {
            try {
              await fetch(actions.secrets.SERVICE_URL, {
                method: 'POST',
                headers: {
                  'X-API-Key': actions.secrets.API_KEY,
                },
                body: JSON.stringify({
                  code,
                  message
                }),
              });

              console.log({
                code,
                message
              });
            } catch (err) {
              throw new Error('External service failure');
            }

            return;
          }
        };
        ```
      </Tab>

      <Tab title="Management API">
        Appelez [Update an Actions Module](/docs/fr-ca/api/management/v2/actions/patch-action-module) avec la requête suivante :

        ```shell theme={null}
        curl -L -X PATCH 'https://{yourDomain}/api/v2/actions/modules/{moduleId}' \
          -H 'Content-Type: application/json' \
          -H 'Authorization: Bearer {yourMgmtApiAccessToken}' \
          -d @code-update.json
        ```

        Où `code-update.json` contient le `code` du module sous forme de chaîne échappée en JSON :

        ```json title="code-update.json" theme={null}
        {
          "code": "module.exports = {\n  sendLog: async (code, message) => {\n    try {\n      await fetch(actions.secrets.SERVICE_URL, {\n        method: 'POST',\n        headers: {\n          'X-API-Key': actions.secrets.API_KEY,\n        },\n        body: JSON.stringify({ code, message }),\n      });\n\n      console.log({ code, message });\n    } catch (err) {\n      throw new Error('External service failure');\n    }\n\n    return;\n  }\n};"
        }
        ```
      </Tab>

      <Tab title="Auth0 CLI">
        Enregistrez le code du module dans `code-update.json` :

        ```json title="code-update.json" theme={null}
        {
          "code": "module.exports = {\n  sendLog: async (code, message) => {\n    try {\n      await fetch(actions.secrets.SERVICE_URL, {\n        method: 'POST',\n        headers: {\n          'X-API-Key': actions.secrets.API_KEY,\n        },\n        body: JSON.stringify({ code, message }),\n      });\n\n      console.log({ code, message });\n    } catch (err) {\n      throw new Error('External service failure');\n    }\n\n    return;\n  }\n};"
        }
        ```

        Puis transmettez-le à [Update an Actions Module](/docs/fr-ca/api/management/v2/actions/patch-action-module) au moyen de `auth0 api` :

        ```shell theme={null}
        cat code-update.json | auth0 api patch actions/modules/{moduleId}
        ```
      </Tab>

      <Tab title="Terraform">
        1. Mettez à jour le fichier de code du module situé à `action-modules/logger/code.js` :

        ```javascript title="action-modules/logger/code.js" theme={null}
        module.exports = {
          sendLog: async (code, message) => {
            try {
              await fetch(actions.secrets.SERVICE_URL, {
                method: 'POST',
                headers: {
                  'X-API-Key': actions.secrets.API_KEY,
                },
                body: JSON.stringify({
                  code,
                  message
                }),
              });

              console.log({
                code,
                message
              });
            } catch (err) {
              throw new Error('External service failure');
            }

            return;
          }
        };
        ```

        2. L’attribut `code` de la ressource `auth0_action_module` référence déjà ce fichier; exécutez donc `terraform apply` pour appliquer la modification.
      </Tab>

      <Tab title="Auth0 Deploy CLI">
        Mettez à jour `action-modules/logger/code.js` avec la logique du module :

        ```javascript title="action-modules/logger/code.js" theme={null}
        module.exports = {
          sendLog: async (code, message) => {
            try {
              await fetch(actions.secrets.SERVICE_URL, {
                method: 'POST',
                headers: {
                  'X-API-Key': actions.secrets.API_KEY,
                },
                body: JSON.stringify({
                  code,
                  message
                }),
              });

              console.log({
                code,
                message
              });
            } catch (err) {
              throw new Error('External service failure');
            }

            return;
          }
        };
        ```
      </Tab>
    </Tabs>

    <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
      À noter :

      * [Directives de codage](/docs/fr-ca/customize/actions/action-coding-guidelines#actions-modules)
      * [Limites](/docs/fr-ca/customize/actions/limitations#actions-modules)
    </Callout>
  </Step>

  <Step title="Enregistrer le brouillon">
    Vous pouvez enregistrer un brouillon de votre Action Module.

    <Tabs>
      <Tab title="Dashboard">
        1. Sélectionnez **Save Draft**.

        <Frame>
          <img src="https://mintlify.s3.us-west-1.amazonaws.com/auth0-automated-translations-update/docs/images/customize/actions/modules/actions-modules-draft.png" alt="Actions Modules - Brouillon enregistré" />
        </Frame>
      </Tab>

      <Tab title="Management API">
        Il n’existe pas d’appel "save" distinct. Chaque requête [Update an Actions Module](/docs/fr-ca/api/management/v2/actions/patch-action-module) effectuée aux étapes précédentes a déjà enregistré vos modifications dans le brouillon du module. Vous pouvez le confirmer avec [Get an Actions Module](/docs/fr-ca/api/management/v2/actions/get-action-module) :

        ```shell theme={null}
        curl -L 'https://{yourDomain}/api/v2/actions/modules/{moduleId}' \
          -H 'Authorization: Bearer {yourMgmtApiAccessToken}'
        ```

        Le champ `all_changes_published` de la réponse est `false`, ce qui confirme que le brouillon contient des modifications non publiées.
      </Tab>

      <Tab title="Auth0 CLI">
        Il n’existe pas d’appel "save" distinct. Chaque requête `auth0 api patch actions/modules/{moduleId}` effectuée aux étapes précédentes a déjà enregistré vos modifications dans le brouillon du module. Vous pouvez le confirmer avec [Get an Actions Module](/docs/fr-ca/api/management/v2/actions/get-action-module) :

        ```shell theme={null}
        auth0 api get actions/modules/{moduleId}
        ```

        Le champ `all_changes_published` de la réponse est `false`, ce qui confirme que le brouillon contient des modifications non publiées.
      </Tab>

      <Tab title="Terraform">
        Il n’existe pas d’étape "save" distincte. La commande `terraform apply` que vous avez exécutée aux étapes précédentes a déjà mis à jour le brouillon du module. Le brouillon n’a aucun effet sur les Actions qui utilisent déjà une version publiée du module.
      </Tab>

      <Tab title="Auth0 Deploy CLI">
        Définissez `all_changes_published` à `false` dans l’entrée du module.

        <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
          Il n’existe pas d’étape "save" distincte.
        </Callout>

        <Tabs>
          <Tab title="YAML">
            Mettez à jour `tenant.yaml` :

            ```yaml highlight={3} title="tenant.yaml" theme={null}
            actionModules:
              - name: logger
                all_changes_published: false
                secrets:
                  - name: SERVICE_URL
                    value: ##SERVICE_URL##
                code: ./action-modules/logger/code.js
            ```

            Redéployez la configuration pour publier la modification :

            ```shell theme={null}
            a0deploy import -c=config.json --input_file=tenant.yaml
            ```
          </Tab>

          <Tab title="Directory (JSON)">
            Mettez à jour `action-modules/logger.json` :

            ```json highlight={2} title="action-modules/logger.json" theme={null}
            {
              "all_changes_published": false,
              "name": "logger",
              "secrets": [
                { "name": "SERVICE_URL", "value": "##SERVICE_URL##" }
              ],
              "code": "./action-modules/logger/code.js"
            }
            ```

            Redéployez la configuration pour publier la modification :

            ```shell theme={null}
            a0deploy import -c=config.json --input_file=local.
            ```
          </Tab>
        </Tabs>
      </Tab>
    </Tabs>

    Cette opération enregistre votre Action Module sans publier de nouvelle version; elle n’aura donc aucun effet sur les Actions qui l’utilisent.
  </Step>

  <Step title="Publier le module Action">
    Une fois que vous êtes satisfait du code de l’Action Module, il est temps de le **publier**.

    <Tabs>
      <Tab title="Dashboard">
        1. Sélectionnez **Publier**.

        <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
          La publication d’un Action Module en crée un instantané à ce moment précis et l’enregistre comme une **version d’Action Module**.
        </Callout>

        2. Sélectionnez **Afficher l’historique des versions**.

        <Frame>
          <img src="https://mintlify.s3.us-west-1.amazonaws.com/auth0-automated-translations-update/docs/images/customize/actions/modules/actions-modules-published-version.png" alt="Actions Modules - Historique des versions" />
        </Frame>

        Auth0 affiche la liste des versions d’Action Module, y compris le brouillon.
      </Tab>

      <Tab title="Management API">
        Appelez [Create an Actions Module Version](/docs/fr-ca/api/management/v2/actions/post-action-module-version), qui crée un instantané du brouillon actuel et le publie :

        ```shell theme={null}
        curl -L -X POST 'https://{yourDomain}/api/v2/actions/modules/{moduleId}/versions' \
          -H 'Authorization: Bearer {yourMgmtApiAccessToken}'
        ```

        Auth0 retourne la nouvelle **version d’Action Module**, y compris son `id` et son `version_number`. Vous référencerez cet `id` comme `module_version_id` lorsque vous ajouterez le module à une Action.
      </Tab>

      <Tab title="Auth0 CLI">
        Appelez [Create an Actions Module Version](/docs/fr-ca/api/management/v2/actions/post-action-module-version) avec `auth0 api`, qui crée un instantané du brouillon actuel et le publie :

        ```shell theme={null}
        auth0 api post actions/modules/{moduleId}/versions
        ```

        Auth0 retourne la nouvelle **version d’Action Module**, y compris son `id` et son `version_number`. Vous référencerez cet `id` comme `module_version_id` lorsque vous ajouterez le module à une Action.
      </Tab>

      <Tab title="Terraform">
        Définissez `publish` à `true` sur la ressource, puis exécutez `terraform apply` :

        ```terraform highlight={4} title="action-modules/logger.tf" theme={null}
        resource "auth0_action_module" "logger" {
          name    = "logger"
          code    = file("${path.module}/action-modules/logger/code.js")
          publish = true

          secrets {
            name  = "SERVICE_URL"
            value = "https://example.com/logs"
          }
        }
        ```

        La publication crée une nouvelle **version d’Action Module** à partir du brouillon actuel. Terraform expose l’ID de la version publiée dans l’attribut calculé `version_id`, que vous référencez depuis les ressources `auth0_action` sous le nom `module_version_id`.
      </Tab>

      <Tab title="Auth0 Deploy CLI">
        Définissez `all_changes_published` à `true` dans l’entrée du module.

        <Tabs>
          <Tab title="YAML">
            Mettez à jour `tenant.yaml` :

            ```yaml highlight={3} title="tenant.yaml" theme={null}
            actionModules:
              - name: logger
                all_changes_published: true
                secrets:
                  - name: SERVICE_URL
                    value: ##SERVICE_URL##
                code: ./action-modules/logger/code.js
            ```

            Redéployez la configuration pour publier le changement :

            ```shell theme={null}
            a0deploy import -c=config.json --input_file=tenant.yaml
            ```
          </Tab>

          <Tab title="Directory (JSON)">
            Mettez à jour `action-modules/logger.json` :

            ```json highlight={2} title="action-modules/logger.json" theme={null}
            {
              "all_changes_published": true,
              "name": "logger",
              "secrets": [
                { "name": "SERVICE_URL", "value": "##SERVICE_URL##" }
              ],
              "code": "./action-modules/logger/code.js"
            }
            ```

            Redéployez la configuration pour publier le changement :

            ```shell theme={null}
            a0deploy import -c=config.json --input_file=local.
            ```
          </Tab>
        </Tabs>

        Cette opération publie une nouvelle **version d’Action Module** à partir du brouillon actuel, après l’application de vos changements.
      </Tab>
    </Tabs>

    Vous pouvez maintenant utiliser l’Action Module dans une Action.

    <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
      Chaque **Action** doit faire explicitement référence à la **version d’Action Module**, ce qui empêche les mises à niveau automatiques susceptibles d’introduire des erreurs inattendues.
    </Callout>
  </Step>

  <Step title="Ajouter l’Action Module à une Action">
    Ensuite, ajoutez le module d’action dans une action.

    <Tabs>
      <Tab title="Dashboard">
        1. Accédez à [Auth0 Dashboard > Actions > Library](https://manage.auth0.com/#/actions/library), puis sélectionnez une **Action** spécifique.
        2. Dans l’éditeur d’Action, sélectionnez l’icône **<svg style={{ display: 'inline' }} width="20" height="20" viewBox="0 0 24 24" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="sc-hQYogJ"><path fill-rule="evenodd" clip-rule="evenodd" d="M9.388 4.07A3.717 3.717 0 0112 3c.977 0 1.917.383 2.612 1.07A3.65 3.65 0 0115.7 6.667a3.65 3.65 0 01-1.028 2.537l1.683 2.778-1.71 1.036-1.701-2.806a3.733 3.733 0 01-3.556-.948A3.65 3.65 0 018.3 6.667c0-.977.393-1.91 1.088-2.597zM12 5c-.455 0-.889.179-1.207.493a1.65 1.65 0 00-.493 1.174c0 .438.176.86.493 1.174.318.314.752.492 1.207.492.455 0 .889-.178 1.207-.492a1.65 1.65 0 00.493-1.174c0-.438-.176-.86-.493-1.174A1.717 1.717 0 0012 5zM6.697 13.802l1.98-2.87 1.646 1.136-1.911 2.77c.633.677.988 1.567.988 2.495a3.65 3.65 0 01-1.088 2.597A3.717 3.717 0 015.7 21a3.717 3.717 0 01-2.612-1.07A3.65 3.65 0 012 17.333c0-.976.393-1.91 1.088-2.597a3.717 3.717 0 013.61-.934zM5.7 15.667c-.455 0-.889.178-1.206.492A1.65 1.65 0 004 17.333c0 .438.176.86.494 1.175.317.313.751.492 1.206.492.455 0 .889-.179 1.206-.492a1.65 1.65 0 00.494-1.175c0-.438-.176-.86-.494-1.174a1.717 1.717 0 00-1.206-.492zM15.688 14.736a3.717 3.717 0 012.612-1.07c.977 0 1.917.384 2.612 1.07A3.65 3.65 0 0122 17.333a3.65 3.65 0 01-1.088 2.597A3.717 3.717 0 0118.3 21a3.717 3.717 0 01-2.612-1.07 3.66 3.66 0 01-.948-1.597H11v-2h3.74c.172-.6.496-1.15.948-1.597zm2.612.93c-.455 0-.889.18-1.207.493a1.65 1.65 0 00-.493 1.174c0 .438.176.86.493 1.175.318.313.752.492 1.207.492.455 0 .889-.179 1.206-.492A1.65 1.65 0 0020 17.332c0-.438-.176-.86-.494-1.174a1.717 1.717 0 00-1.206-.492z" fill="inherit" /></svg>** dans la barre latérale gauche.
        3. Sélectionnez **Ajouter un module**.
        4. Sélectionnez un **Nom** et une **Version** de module.
        5. Sélectionnez **Ajouter**.

        <Frame>
          <img src="https://mintlify.s3.us-west-1.amazonaws.com/auth0-automated-translations-update/docs/images/customize/actions/modules/actions-modules-add-module.png" alt="Actions - Ajouter un module d’action" />
        </Frame>
      </Tab>

      <Tab title="Management API">
        Appelez [Update an Action](/docs/fr-ca/api/management/v2/actions/patch-action) avec les valeurs `module_id` et `module_version_id` du module obtenues à l’étape précédente :

        ```shell theme={null}
        curl -L -X PATCH 'https://{yourDomain}/api/v2/actions/actions/{actionId}' \
          -H 'Content-Type: application/json' \
          -H 'Authorization: Bearer {yourMgmtApiAccessToken}' \
          -d '{
            "modules": [
              {
                "module_id": "{moduleId}",
                "module_version_id": "{moduleVersionId}"
              }
            ]
          }'
        ```
      </Tab>

      <Tab title="Auth0 CLI">
        <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
          [`auth0 actions update`](https://auth0.github.io/auth0-cli/auth0_actions_update.html) n’a aucun indicateur pour les Action Modules; appelez donc directement [Update an Action](/docs/fr-ca/api/management/v2/actions/patch-action) avec `auth0 api`, en utilisant les `module_id` et `module_version_id` du module obtenus à l’étape précédente :
        </Callout>

        ```shell theme={null}
        auth0 api patch actions/actions/{actionId} --data '{
          "modules": [
            {
              "module_id": "{moduleId}",
              "module_version_id": "{moduleVersionId}"
            }
          ]
        }'
        ```
      </Tab>

      <Tab title="Terraform">
        Ajoutez un bloc `modules` à la ressource `auth0_action`, en y référençant le module et sa version publiée. Laissez l’attribut `code` pointer vers le fichier de code propre à l’Action :

        ```terraform highlight={3,5-8} title="actions/my-action.tf" theme={null}
        resource "auth0_action" "my_action" {
          name = "my-action"
          code = file("${path.module}/actions/my-action/code.js")

          modules {
            module_id         = auth0_action_module.logger.id
            module_version_id = auth0_action_module.logger.version_id
          }

          supported_triggers {
            id      = "post-login"
            version = "v3"
          }
        }
        ```
      </Tab>

      <Tab title="Auth0 Deploy CLI">
        Ajoutez un tableau `modules` à la configuration de l’Action, en référençant le module par son nom et son numéro de version.

        <Tabs>
          <Tab title="YAML">
            Ajoutez le tableau `modules` à l’entrée de l’Action dans `tenant.yaml` :

            ```yaml highlight={7-9} title="tenant.yaml" theme={null}
            actions:
              - name: my-action
                code: ./actions/my-action/code.js
                supported_triggers:
                  - id: post-login
                    version: v3
                modules:
                  - module_name: logger
                    module_version_number: 1
            ```
          </Tab>

          <Tab title="Directory (JSON)">
            Ajoutez le tableau `modules` au fichier de configuration de l’Action (par exemple, `actions/my-action.json`) :

            ```json highlight={2-5} title="actions/my-action.json" theme={null}
            {
              "modules": [
                { "module_name": "logger", "module_version_number": 1 }
              ],
              "name": "my-action",
              "code": "./actions/my-action/code.js",
              "supported_triggers": [
                { "id": "post-login", "version": "v3" }
              ]
            }
            ```
          </Tab>
        </Tabs>

        Le Deploy CLI résout `module_name` et `module_version_number` en les véritables `module_id` et `module_version_id` du module au moment du déploiement.
      </Tab>
    </Tabs>
  </Step>

  <Step title="Utilisez le module d’action dans l’Action">
    Maintenant, utilisons l’Action Module dans l’Action.

    <Tabs>
      <Tab title="Dashboard">
        1. Ajoutez l’instruction **require**.

        ```javascript theme={null}
        const logger = require('actions:logger');
        ```

        <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
          L’instruction **require** fait référence à l’Action Module au format **actions:\[module-name]**.
        </Callout>

        2. Ajoutez l’appel à `logger.sendLog` dans la **fonction Action**, à l’endroit où vous souhaitez envoyer des logs.

        ```javascript theme={null}
        await logger.sendLog('logger_success', 'Your Action was able to use the Logger Action Module');
        ```

        3. Sélectionnez **Deploy** pour déployer l’Action.

        <Frame>
          <img src="https://mintlify.s3.us-west-1.amazonaws.com/auth0-automated-translations-update/docs/images/customize/actions/modules/actions-modules-use-module.png" alt="Actions - Use Action Module" />
        </Frame>
      </Tab>

      <Tab title="Management API">
        1. Appelez [Update an Action](/docs/fr-ca/api/management/v2/actions/patch-action) pour ajouter l’instruction `require` et l’appel à `logger.sendLog` au `code` de l’Action :

        ```shell theme={null}
        curl -L -X PATCH 'https://{yourDomain}/api/v2/actions/actions/{actionId}' \
          -H 'Content-Type: application/json' \
          -H 'Authorization: Bearer {yourMgmtApiAccessToken}' \
          -d @code-update.json
        ```

        Où `code-update.json` contient :

        ```json title="code-update.json" theme={null}
        {
          "code": "const logger = require('actions:logger');\n\nexports.onExecutePostLogin = async (event, api) => {\n  await logger.sendLog('logger_success', 'Your Action was able to use the Logger Action Module');\n};"
        }
        ```

        2. Appelez [Deploy an Action](/docs/fr-ca/api/management/v2/actions/post-deploy-action) :

        ```shell theme={null}
        curl -L -X POST 'https://{yourDomain}/api/v2/actions/actions/{actionId}/deploy' \
          -H 'Authorization: Bearer {yourMgmtApiAccessToken}'
        ```
      </Tab>

      <Tab title="Auth0 CLI">
        1. Mettez à jour le fichier de code de l’Action situé à `actions/my-action/code.js` avec l’instruction `require` et l’appel à `logger.sendLog` :

        ```javascript title="actions/my-action/code.js" theme={null}
        const logger = require('actions:logger');

        exports.onExecutePostLogin = async (event, api) => {
          await logger.sendLog('logger_success', 'Your Action was able to use the Logger Action Module');
        };
        ```

        2. Mettez à jour l’Action avec [`auth0 actions update`](https://auth0.github.io/auth0-cli/auth0_actions_update.html) et déployez-la avec [`auth0 actions deploy`](https://auth0.github.io/auth0-cli/auth0_actions_deploy.html) :

        ```shell theme={null}
        auth0 actions update {actionId} --code "$(cat actions/my-action/code.js)"
        auth0 actions deploy {actionId}
        ```
      </Tab>

      <Tab title="Terraform">
        1. Mettez à jour le fichier de code de l’Action situé à `actions/my-action/code.js` avec l’instruction `require` et l’appel à `logger.sendLog` :

        ```javascript title="actions/my-action/code.js" theme={null}
        const logger = require('actions:logger');

        exports.onExecutePostLogin = async (event, api) => {
          await logger.sendLog('logger_success', 'Your Action was able to use the Logger Action Module');
        };
        ```

        2. Définissez `deploy` à `true` sur la ressource `auth0_action`, puis exécutez `terraform apply` :

        ```terraform highlight={3} title="actions/my-action.tf" theme={null}
        resource "auth0_action" "my_action" {
          name    = "my-action"
          deploy  = true
          code    = file("${path.module}/actions/my-action/code.js")

          modules {
            module_id         = auth0_action_module.logger.id
            module_version_id = auth0_action_module.logger.version_id
          }

          supported_triggers {
            id      = "post-login"
            version = "v3"
          }
        }
        ```

        Définir `deploy = true` crée immédiatement une nouvelle version déployée de l’Action.
      </Tab>

      <Tab title="Auth0 Deploy CLI">
        1. Ajoutez l’instruction `require` et l’appel à `logger.sendLog` dans `actions/my-action/code.js` :

        ```javascript title="actions/my-action/code.js" theme={null}
        const logger = require('actions:logger');

        exports.onExecutePostLogin = async (event, api) => {
          await logger.sendLog('logger_success', 'Your Action was able to use the Logger Action Module');
        };
        ```

        2. Redéployez la configuration :

        ```shell theme={null}
        a0deploy import -c=config.json --input_file=local.
        ```
      </Tab>
    </Tabs>

    <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
      N’oubliez pas d’associer l’Action à un Trigger.
    </Callout>
  </Step>
</Steps>

<Check>
  **Vérification**

  Vous devriez maintenant avoir un **Action Module** entièrement fonctionnel utilisé par une **Action**.
</Check>

***

<h2 id="advanced-usage">
  Utilisation avancée
</h2>

<Accordion title="Dépendances NPM">
  Chaque **Action Module** peut ajouter et utiliser des **[dépendances NPM](https://www.npmjs.com/)**.

  <Tabs>
    <Tab title="Dashboard">
      1. Sélectionnez l’icône **<svg style={{ display: 'inline' }} width="20" height="20" viewBox="0 0 24 24" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="sc-lgWczb"><path fill-rule="evenodd" clip-rule="evenodd" d="M3.543 5.02l7.197-3.715h.003a2.75 2.75 0 012.514 0h.003l7.197 3.715h.002A2.864 2.864 0 0122 7.573v8.853a2.866 2.866 0 01-1.543 2.553l-7.197 3.714a2.75 2.75 0 01-2.529 0l-7.2-3.715-.002-.002A2.865 2.865 0 012 16.413v-8.84A2.865 2.865 0 013.543 5.02zm8.113-1.937l-1.97 1.018L16.5 7.618l2.315-1.195-6.47-3.34h-.001a.75.75 0 00-.688 0zM20 8.063l-7 3.611v8.902l6.542-3.377h.003a.865.865 0 00.455-.774V8.062zM11 20.58v-8.905L4 8.062v8.36a.866.866 0 00.45.778h.001L11 20.58zM5.185 6.423L12 9.94l2.32-1.197-6.815-3.517-2.32 1.197z" fill="inherit" /></svg>** dans la barre latérale gauche de l’éditeur de code.
      2. Sélectionnez **Add Dependency**.
      3. Saisissez le **Name** du **package NPM**.
      4. Saisissez la **Version** du **package NPM**.
      5. Sélectionnez **Create**.

      <Frame>
        <img src="https://mintlify.s3.us-west-1.amazonaws.com/auth0-automated-translations-update/docs/images/customize/actions/modules/actions-modules-dependency.png" alt="Modules Action - Dépendance ajoutée" />
      </Frame>

      Auth0 ajoute la dépendance à la liste des dépendances du Action Module.
    </Tab>

    <Tab title="Management API">
      Appelez [Update an Actions Module](/docs/fr-ca/api/management/v2/actions/patch-action-module) avec un tableau `dependencies` :

      ```shell theme={null}
      curl -L -X PATCH 'https://{yourDomain}/api/v2/actions/modules/{moduleId}' \
        -H 'Content-Type: application/json' \
        -H 'Authorization: Bearer {yourMgmtApiAccessToken}' \
        -d '{
          "dependencies": [
            { "name": "lodash", "version": "4.17.21" }
          ]
        }'
      ```

      Comme pour les `secrets`, chaque appel `PATCH` remplace l’intégralité du tableau `dependencies`; incluez donc toutes les dépendances dont le module a besoin.
    </Tab>

    <Tab title="Auth0 CLI">
      Appelez [Update an Actions Module](/docs/fr-ca/api/management/v2/actions/patch-action-module) avec `auth0 api`, en utilisant un tableau `dependencies` :

      ```shell theme={null}
      auth0 api patch actions/modules/{moduleId} --data '{
        "dependencies": [
          { "name": "lodash", "version": "4.17.21" }
        ]
      }'
      ```

      Comme pour `secrets`, chaque appel remplace l’ensemble du tableau `dependencies` : incluez donc toutes les dépendances dont le module a besoin.
    </Tab>

    <Tab title="Terraform">
      Ajoutez un bloc `dependencies` à la ressource `auth0_action_module`, puis exécutez `terraform apply` :

      ```terraform highlight={4-7} title="action-modules/logger.tf" theme={null}
      resource "auth0_action_module" "logger" {
        name = "logger"
        code = file("${path.module}/action-modules/logger/code.js")

        dependencies {
          name    = "lodash"
          version = "4.17.21"
        }
      }
      ```
    </Tab>

    <Tab title="CLI Auth0 Deploy">
      Ajoutez un tableau `dependencies` à la configuration du module.

      <Tabs>
        <Tab title="YAML">
          Ajoutez le tableau `dependencies` à l’entrée du module dans `tenant.yaml` :

          ```yaml highlight={3-5} title="tenant.yaml" theme={null}
          actionModules:
            - name: logger
              dependencies:
                - name: lodash
                  version: 4.17.21
              code: ./action-modules/logger/code.js
          ```
        </Tab>

        <Tab title="Directory (JSON)">
          Ajoutez le tableau `dependencies` à `action-modules/logger.json` :

          ```json highlight={2-4} title="action-modules/logger.json" theme={null}
          {
            "dependencies": [
              { "name": "lodash", "version": "4.17.21" }
            ],
            "name": "logger",
            "code": "./action-modules/logger/code.js"
          }
          ```
        </Tab>
      </Tabs>
    </Tab>
  </Tabs>

  <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
    Utilisez les **dépendances** répertoriées dans le Action Module en les important avec `require('[package-name]')`.
  </Callout>

  <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
    Lorsque vous enregistrez cette Action, Auth0 résout la version la plus récente de votre dépendance et la remplace par un numéro de version précis afin d’éviter que de futures mises à jour du package ne brisent votre Action.

    Vous pouvez fournir une version précise au lieu de latest.
  </Callout>
</Accordion>