> ## Documentation Index
> Fetch the complete documentation index at: https://auth0.com/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

## Pour commencer

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

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

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

![Actions Modules - Nouvel Action Module](https://mintlify.s3.us-west-1.amazonaws.com/auth0/docs/images/customize/actions/modules/actions-modules-new-module.png)

**Management API**

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

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

**Auth0 CLI**

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

Appelez [Create an Actions Module](https://auth0.com/docs/fr-ca/api/management/v2/actions/post-action-module.md) 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.

**Terraform**

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.

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.

**Auth0 Deploy CLI**

**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
```

**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.
```

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

**Dashboard**

Ensuite, enregistrez l’URL du service externe comme Secret.

1. Sélectionnez l’icône \*\*\*\* 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**.

![Modules d’action - Secret ajouté](https://mintlify.s3.us-west-1.amazonaws.com/auth0/docs/images/customize/actions/modules/actions-modules-secret.png)

Auth0 ajoute le Secret à la liste des Secrets du module d’action.

**Management API**

Ensuite, enregistrez l’URL du service externe comme Secret. Appelez [Update an Actions Module](https://auth0.com/docs/fr-ca/api/management/v2/actions/patch-action-module.md) 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.

**Auth0 CLI**

Ensuite, enregistrez l’URL du service externe comme Secret. Appelez [Update an Actions Module](https://auth0.com/docs/fr-ca/api/management/v2/actions/patch-action-module.md) 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.

**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"
  }
}
```

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.

**Auth0 Déployer CLI**

Ensuite, enregistrez l’URL du service externe comme Secret.

**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
```

**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"
}
```

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.

**É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.

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.

Chaque **Secret de module d’action** est indépendant des autres **Modules d’action** et des **Secrets des Actions**.

Utilisez les **Secrets** dans le module d’action en saisissant `actions.secrets.[secret_key]`.

### 3. Ajouter de la logique personnalisée

Maintenant, ajoutez le code suivant à votre module d’action.

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

**Management API**

Appelez [Update an Actions Module](https://auth0.com/docs/fr-ca/api/management/v2/actions/patch-action-module.md) 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};"
}
```

**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](https://auth0.com/docs/fr-ca/api/management/v2/actions/patch-action-module.md) au moyen de `auth0 api` :

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

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

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

À noter :

* [Directives de codage](https://auth0.com/docs/fr-ca/customize/actions/action-coding-guidelines.md#actions-modules)
* [Limites](https://auth0.com/docs/fr-ca/customize/actions/limitations.md#actions-modules)

### 4. Enregistrer le brouillon

Vous pouvez enregistrer un brouillon de votre Action Module.

**Dashboard**

1. Sélectionnez **Save Draft**.

![Actions Modules - Brouillon enregistré](https://mintlify.s3.us-west-1.amazonaws.com/auth0/docs/images/customize/actions/modules/actions-modules-draft.png)

**Management API**

Il n’existe pas d’appel "save" distinct. Chaque requête [Update an Actions Module](https://auth0.com/docs/fr-ca/api/management/v2/actions/patch-action-module.md) 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](https://auth0.com/docs/fr-ca/api/management/v2/actions/get-action-module.md) :

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

**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](https://auth0.com/docs/fr-ca/api/management/v2/actions/get-action-module.md) :

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

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

**Auth0 Deploy CLI**

Définissez `all_changes_published` à `false` dans l’entrée du module.

Il n’existe pas d’étape "save" distincte.

**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
```

**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.
```

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

### 5. Publier le module Action

Une fois que vous êtes satisfait du code de l’Action Module, il est temps de le **publier**.

**Dashboard**

1. Sélectionnez **Publier**.

La publication d’un Action Module en crée un instantané à ce moment précis et l’enregistre comme une **version d’Action Module**.

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

![Actions Modules - Historique des versions](https://mintlify.s3.us-west-1.amazonaws.com/auth0/docs/images/customize/actions/modules/actions-modules-published-version.png)

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

**Management API**

Appelez [Create an Actions Module Version](https://auth0.com/docs/fr-ca/api/management/v2/actions/post-action-module-version.md), 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.

**Auth0 CLI**

Appelez [Create an Actions Module Version](https://auth0.com/docs/fr-ca/api/management/v2/actions/post-action-module-version.md) 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.

**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`.

**Auth0 Deploy CLI**

Définissez `all_changes_published` à `true` dans l’entrée du module.

**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
```

**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.
```

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

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

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.

### 6. Ajouter l’Action Module à une Action

Ensuite, ajoutez le module d’action dans une action.

**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 \*\*\*\* 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**.

![Actions - Ajouter un module d’action](https://mintlify.s3.us-west-1.amazonaws.com/auth0/docs/images/customize/actions/modules/actions-modules-add-module.png)

**Management API**

Appelez [Update an Action](https://auth0.com/docs/fr-ca/api/management/v2/actions/patch-action.md) 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}"
      }
    ]
  }'
```

**Auth0 CLI**

[`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](https://auth0.com/docs/fr-ca/api/management/v2/actions/patch-action.md) avec `auth0 api`, en utilisant les `module_id` et `module_version_id` du module obtenus à l’étape précédente :

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

**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"
  }
}
```

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

**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
```

**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" }
  ]
}
```

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.

### 7. Utilisez le module d’action dans l’Action

Maintenant, utilisons l’Action Module dans l’Action.

**Dashboard**

1. Ajoutez l’instruction **require**.

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

L’instruction **require** fait référence à l’Action Module au format **actions:\[module-name]**.

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.

![Actions - Use Action Module](https://mintlify.s3.us-west-1.amazonaws.com/auth0/docs/images/customize/actions/modules/actions-modules-use-module.png)

**Management API**

1. Appelez [Update an Action](https://auth0.com/docs/fr-ca/api/management/v2/actions/patch-action.md) 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](https://auth0.com/docs/fr-ca/api/management/v2/actions/post-deploy-action.md) :

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

**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}
```

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

**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.
```

N’oubliez pas d’associer l’Action à un Trigger.

> [!TIP]
>
> **Vérification**
>
> Vous devriez maintenant avoir un **Action Module** entièrement fonctionnel utilisé par une **Action**.

***

## Utilisation avancée

> **Dépendances NPM**
>
> Chaque **Action Module** peut ajouter et utiliser des **[dépendances NPM](https://www.npmjs.com/)**.
>
> **Dashboard**
>
> 1. Sélectionnez l’icône \*\*\*\* 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**.
>
> ![Modules Action - Dépendance ajoutée](https://mintlify.s3.us-west-1.amazonaws.com/auth0/docs/images/customize/actions/modules/actions-modules-dependency.png)
>
> Auth0 ajoute la dépendance à la liste des dépendances du Action Module.
>
> **Management API**
>
> Appelez [Update an Actions Module](https://auth0.com/docs/fr-ca/api/management/v2/actions/patch-action-module.md) 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.
>
> **Auth0 CLI**
>
> Appelez [Update an Actions Module](https://auth0.com/docs/fr-ca/api/management/v2/actions/patch-action-module.md) 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.
>
> **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"
>   }
> }
> ```
>
> **CLI Auth0 Deploy**
>
> Ajoutez un tableau `dependencies` à la configuration du module.
>
> **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
> ```
>
> **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"
> }
> ```
>
> Utilisez les **dépendances** répertoriées dans le Action Module en les important avec `require('[package-name]')`.
>
> 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.