> ## Documentation Index
> Fetch the complete documentation index at: https://docs-dev-actions-triggers-prototype.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Sécuriser les points de terminaison de la passerelle API AWS en utiilisant des autorisateurs personnalisés

> Comment sécuriser les points terminaux de la passerelle API AWS en utiilisant des autorisateurs personnalisés qui acceptent les jetons d’accès émis par Auth0.

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) + "*****MASKED*****";
          }
          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>;
};

Sécuriser les points de terminaison de la passerelle API AWS en utiilisant des autorisateurs personnalisés qui acceptent les jetons d’accès émis par Auth0. Pour faire cela, vous configurez votre API avec la passerelle API, créez et configurez vos fonctions Lambda AWS (incluant les autorisateurs personnalisés) pour sécuriser vos points de terminaison AWS, et mettez en oeuvre le fllux d’autorisation afin que vos utilisateurs puissent récupérer les jetons d’accès requis pour avoir accès à votre API depuis Auth0.

Pour en savoir plus, visitez [Aperçu Lambda AWS](https://aws.amazon.com/lambda/) une fois connecté à votre [Passerelle API AWS](https://aws.amazon.com/api-gateway/).

La passerelle API étend les capacités de Lambda en ajoutant une couche de service devant vos fonctions Lambda pour étendre la sécurité, gérer les transformations des messages d’entrée et de sortie et fournir des capacités telles que la limitation de taux et l’audit. Une approche sans serveur simplifie vos demandes opérationnelles puisque les préoccupations telles que la croissance et la tolérance aux pannes sont désormais de la responsabilité du service de calcul qui exécute votre code.

Les autorisateurs personnalisés vont :

* Confirmer que le jeton d’accès a été transmis via l’en-tête `authorization` de la demande d’accès à l’API.
* Vérifier la signature RS256 du jeton d'accès à l'aide d'une clé publique obtenue via un point de terminaison JWKS.
* S’assurer que le jeton d’accès comporte les demandes requises de l’émetteur `iss` et d'<Tooltip data-tooltip-id="react-containers-DefinitionTooltip-0" tip="">audience</Tooltip> `aud`.

Suivez les étapes suivantes pour utiliser des autorisateurs personnalisés :

1. [Créer une API Auth0](#create-an-auth0-api)
2. [Importer et déployer l’API passerelle AWS API.](#import-and-deploy-the-aws-api-gateway-api)
3. [Créer les autorisateurs personnalisés](#create-the-custom-authorizers)
4. [Sécuriser l’API à l’aide d’autorisateurs personnalisés](#secure-the-api-using-custom-authorizers)
5. [Tester votre déploiement](#test-your-deployment)

Pour en savoir plus sur les algorithmes de signature, lisez [Algorithmes de signature](/docs/fr-ca/get-started/applications/signing-algorithms). Pour plus de détails sur l’utilisation de JWKS, consultez [JSON Web Key Sets](/docs/fr-ca/secure/tokens/json-web-tokens/json-web-key-sets) (Ensembles de clés JSON Web).

## Fonctionnement des autorisateurs personnalisés de la passerelle API

[Selon Amazon](http://docs.aws.amazon.com/apigateway/latest/developerguide/use-custom-authorizer.html), un autorisateur personnalisé de passerelle API est une « fonction Lambda que vous fournissez pour contrôler l’accès à votre API à l’aide de stratégies d’authentification par jeton du porteur, telles que <Tooltip href="/docs/fr-ca/glossary?term=oath2" tip="OAuth 2.0
Cadre d’applications d’autorisation qui définit les protocoles d’autorisation et les flux de production." cta="Voir le glossaire">OAuth</Tooltip> ou <Tooltip href="/docs/fr-ca/glossary?term=security-assertion-markup-language" tip="Security Assertion Markup Language (SAML)
Protocole normalisé permettant à deux parties d’échanger des informations d’authentification sans mot de passe." cta="Voir le glossaire">SAML</Tooltip> ».

Chaque fois qu’une personne (ou un programme) tente d’appeler votre API, la passerelle API vérifie si un autorisateur personnalisé est configuré pour l’API.

S’**il existe un autorisateur personnalisé pour l’API**, la passerelle API appelle l’autorisateur personnalisé et fournit le jeton d’autorisation extrait de l’en-tête de la demande reçue.

Vous pouvez utiliser l'autorisateur personnalisé pour mettre en œuvre différents types de stratégies d'autorisation, y compris la vérification <Tooltip href="/docs/fr-ca/glossary?term=json-web-token" tip="Jeton Web JSON (JWT)
Format standard de jeton d’ID (et souvent de jeton d’accès) utilisé pour représenter en toute sécurité des demandes entre deux parties." cta="Voir le glossaire">JWT</Tooltip>, pour renvoyer des politiques IAM autorisant la demande. Si la politique renvoyée n'est pas valide ou si les autorisations sont refusées, l'appel à l'API échoue.

Dans le cas d’une politique valide, l’API met en cache la politique renvoyée, l’associe au jeton entrant et l’utilise pour la demande actuelle et les demandes suivantes. Vous pouvez configurer la durée pendant laquelle la politique est mise en cache. La valeur par défaut est `300` secondes et la durée maximale de mise en cache est `3600` secondes (vous pouvez également fixer la valeur à 0 pour désactiver la mise en cache).

Pour en savoir plus, consultez [What is Amazon API Gateway?](http://docs.aws.amazon.com/apigateway/latest/developerguide/use-custom-authorizer.html) (Qu’est-ce que la passerelle API Amazon) dans le Amazon Developer’s Guide. Pour plus d’informations sur la vérification des JWT, consultez notre article [Jeton Web JSON](/docs/fr-ca/secure/tokens/json-web-tokens) .

## Conditions préalables

Vous devez [vous inscrire à un compte AWS](https://portal.aws.amazon.com/gp/aws/developer/registration/index.html). Cela vous permet d’accéder aux fonctionnalités AWS, notamment API Gateway et Lambda. Tous les nouveaux membres bénéficient de douze mois d’accès gratuit à AWS.

## Créer une API Auth0

Configurer les API consommées par les applications qui réussissent à obtenir une autorisation.

1. Rendez-vous au  [Tableau de bord Auth0 > Applications > API](https://manage.auth0.com/#/apis), et sélectionnez **Créer une API**.
2. Saisissez les valeurs des champs suivants et sélectionnez **Créer**.

| Champ                                                | Description                                                                                                                        |
| ---------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| Name                                                 | Un nom convivial pour votre API. C’est le nom que vous verrez dans votre liste d’API Auth0.                                        |
| Identifier                                           | Identifiant unique pour votre API. Nous vous recommandons de formater cet identifiant comme une URL `https://your-api-gateway`.    |
| Profil de jeton Web JSON                             | Profil de jeton OAuth2.0 ou dialectes, pour un jeton d’accès. Pour en savoir plus, veuillez consulter \[Profils de jetons d’accès] |
| (/secure/tokens/access-tokens/access-token-profiles) |                                                                                                                                    |

Pour voir les détails de votre API nouvellement créée, reportez-vous à la vue **Paramètres**.

<Frame>
  <img src="https://mintcdn.com/docs-dev-actions-triggers-prototype/sobog9Qdm0HQ6dwk/docs/images/fr-ca/cdy7uua7fh8z/4P1N7SSCXUF1SfyC8SXTiO/dd57c0590b68fdbfe99990d6ef48feaa/Crate_API_Gateway_-_FR.png?fit=max&auto=format&n=sobog9Qdm0HQ6dwk&q=85&s=45ab79f77277ae765f8f1caa040c8b60" alt="Dashboard – Créer API – Passerelle AWS API" width="698" height="860" data-path="docs/images/fr-ca/cdy7uua7fh8z/4P1N7SSCXUF1SfyC8SXTiO/dd57c0590b68fdbfe99990d6ef48feaa/Crate_API_Gateway_-_FR.png" />
</Frame>

La création d’une API crée également une application Machine à Machine à utiliser avec l’API. Cette application est répertoriée comme **Authorized** (Autorisée) dans la vue **Application machine à machine**. Prenez note de l’ID client, vous en aurez besoin dans la partie 3 de ce tutoriel.

## Importer et déployer la passerelle API de l’API AWS

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Cette partie du tutoriel a été adaptée à partir de l’[exemple officiel d’AWS](http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-create-api-from-example.html). Veuillez vous référer à cet exemple pour des notes et une discussion approfondies.
</Callout>

Au cours de cette étape, vous allez :

* Importer une API dans la Passerelle API
* Tester une importation d’API
* Déployer une API pour l’utiliser avec n’importe quelle application frontale
* Tester le déploiement d’une API

### Importer et configurer l’API Pets

1. Connectez-vous à votre compte AWS et, à l’aide du menu déroulant **Services** situé dans la barre de navigation supérieure, accédez à la console **API Gateway** (Passerelle API).
2. Si vous avez déjà créé une API, accédez simplement à la console de la passerelle API et cliquez sur **Create API** (Créer une API). Vous aurez la possibilité de créer l’API **Example API** sur le formulaire **Create new API** (Créer une nouvelle API).
   Si vous n’avez jamais créé d’API à l’aide de API Gateway Passerelle API), vous verrez l’écran suivant. Cliquez sur **Get Started** (Commencer) pour continuer.

   <Frame>
     <img src="https://mintcdn.com/docs-dev-actions-triggers-prototype/M4OX-dUcWfCOjXvH/docs/images/fr-ca/cdy7uua7fh8z/3MX6jO6ZzTqEWNZaWps0j5/4b97df023e694e452d4f34f03d15d21c/aws-pt1-1.png?fit=max&auto=format&n=M4OX-dUcWfCOjXvH&q=85&s=ecedaa016d7ca9e2302c4740d9da477f" alt="AWS API Gateway - Get Started" width="687" height="511" data-path="docs/images/fr-ca/cdy7uua7fh8z/3MX6jO6ZzTqEWNZaWps0j5/4b97df023e694e452d4f34f03d15d21c/aws-pt1-1.png" />
   </Frame>

   Vous verrez un message contextuel vous souhaitant la bienvenue dans la Passerelle API. Cliquez sur **OK** pour continuer.
3. Sur le formulaire **Create new API** (Créer une nouvelle API), vous verrez que **Example API** est sélectionné par défaut et qu’un exemple d’API est défini dans l’éditeur. Nous utiliserons cette API pour le reste de notre tutoriel, alors commencez le processus de création d’API en cliquant sur **Import** (Importer).

   <Frame>
     <img src="https://mintcdn.com/docs-dev-actions-triggers-prototype/gqbf-XGz7-Z2BrZ6/docs/images/fr-ca/cdy7uua7fh8z/8b4yGZNUwCNRYovU203Au/d010702b68635ef7e1864554c3a3826f/aws-pt1-4.png?fit=max&auto=format&n=gqbf-XGz7-Z2BrZ6&q=85&s=9d81f7f109624165e5abb5db19ec75d0" alt="AWS API Gateway - Example API" width="687" height="512" data-path="docs/images/fr-ca/cdy7uua7fh8z/8b4yGZNUwCNRYovU203Au/d010702b68635ef7e1864554c3a3826f/aws-pt1-4.png" />
   </Frame>

   Lorsque cela est fait, AWS affiche un message indiquant que votre API a été créée et alimentée avec les données fournies. Vous remarquerez que des méthodes sont déjà associées à l’API (à savoir `GET` et `POST`). Vous pouvez afficher les détails d’une méthode, modifier sa configuration ou tester l’invocation de la méthode en cliquant sur le nom de la méthode dans l’arborescence des ressources.

   <Frame>
     <img src="https://mintcdn.com/docs-dev-actions-triggers-prototype/7ZTj9ECBnaPth0zw/docs/images/fr-ca/cdy7uua7fh8z/1COXG4sI0DNSM4NIMEtma9/9cc6104e234ac25d1098fd92f1183bc1/aws-pt1-5a.png?fit=max&auto=format&n=7ZTj9ECBnaPth0zw&q=85&s=18f20c495b51b295ba9fd651a0815cbe" alt="AWS API Gateway - Resources Tree" width="687" height="511" data-path="docs/images/fr-ca/cdy7uua7fh8z/1COXG4sI0DNSM4NIMEtma9/9cc6104e234ac25d1098fd92f1183bc1/aws-pt1-5a.png" />
   </Frame>

### Tester votre API

Pour tester votre API, cliquez sur **POST** sous `/pets`. La fenêtre **Method Execution** (Exécution de la méthode) s’affiche et donne un aperçu de la structure et des comportements de la méthode `POST` :

* **Method Request** (Requête de méthode) et **Method Response** (Réponse de méthode) : l’interface de l’API avec le front-end
* **Integration Request** (Requête d’intégration) et **Integration Response** (Réponse d’intégration) : l’interface de l’API avec le back-end

Nous pouvons utiliser cette zone pour tester l’API.

1. Cliquez sur **Test** (indiqué sur le ruban **Client** situé au milieu de la page). Vous serez redirigé vers la page `/pets - POST - Method Test` (Test de méthode - POST - /pets). Faites défiler jusqu’au bas de la page et fournissez l’extrait suivant en tant que **Corps de la demande** :

   ```json lines theme={null}
   {"type": "dog", "price": 249.99}
   ```

   Le corps de la demande indique les attributs de l’animal que nous voulons ajouter à la base de données, ainsi que le coût de l’animal.<Frame><img src="https://mintcdn.com/docs-dev-actions-triggers-prototype/AzFg9TUnnX-9tz7j/docs/images/fr-ca/cdy7uua7fh8z/5XKCxyYc5nBCsqln27HVLF/bcd9c16f9e3405fda8cc44f455cb819b/aws-pt1-5d.png?fit=max&auto=format&n=AzFg9TUnnX-9tz7j&q=85&s=9686128eeadcac4f2d6f4280d5997f7a" alt="AWS API Gateway - Request Body" width="684" height="511" data-path="docs/images/fr-ca/cdy7uua7fh8z/5XKCxyYc5nBCsqln27HVLF/bcd9c16f9e3405fda8cc44f455cb819b/aws-pt1-5d.png" /></Frame>

2. Cliquez sur **Test** pour continuer. Vous verrez les résultats du test dans la partie droite de la page.

   <Frame>
     <img src="https://mintcdn.com/docs-dev-actions-triggers-prototype/M4OX-dUcWfCOjXvH/docs/images/fr-ca/cdy7uua7fh8z/2cwnpb0irU5DOVKCjcjnil/986f046738bc3b0f79145daa7b86ff3c/aws-pt1-5e.png?fit=max&auto=format&n=M4OX-dUcWfCOjXvH&q=85&s=89f9e0237fb4d78513dd23428475e8c8" alt="AWS API Gateway - Test Results" width="685" height="512" data-path="docs/images/fr-ca/cdy7uua7fh8z/2cwnpb0irU5DOVKCjcjnil/986f046738bc3b0f79145daa7b86ff3c/aws-pt1-5e.png" />
   </Frame>

### Déployer l’API

Le test que nous venons de réaliser a été effectué à l’aide de la console passerelle API. Pour utiliser l’API avec une autre application, vous devrez déployer l’API sur une version de développement.

1. Dans le menu **Actions**, sélectionnez **Déployer API**.
2. Indiquez les valeurs suivantes et cliquez sur **Déployer**.

| Paramètre                      | Valeur                           |
| ------------------------------ | -------------------------------- |
| **Étape de déploiement**       | Choisir `[Nouvelle étape]`       |
| **Nom de l’étape**             | Indiquez un nom pour votre étape |
| **Description de l’étape**     | Décrivez votre étape             |
| **Description du déploiement** | Décrivez votre déploiement API   |

### Tester le déploiement

Lorsque l’API a été déployée avec succès, vous êtes redirigé vers **Test Stage Editor** (Éditeur de test de développement). Vous pouvez, à ce stade, tester l’API pour voir si elle s’est déployée correctement.

1. En haut de la fenêtre **Test Stage Editor** (Éditeur de test de développement) se trouve une bannière bleue avec votre **Invoke URL**. Il s’agit de l’URL utilisé pour invoquer le point de terminaison `GET` de votre API. Cliquez sur le lien pour soumettre la demande `GET /method` dans un navigateur. Vous devriez obtenir la réponse suivante :

   <Frame>
     <img src="https://mintcdn.com/docs-dev-actions-triggers-prototype/mxRp7IkiVukPESZw/docs/images/fr-ca/cdy7uua7fh8z/7d8340OcAtOF8GvBtihRBt/958eff065c665682ef53b9eedae77a8e/aws-pt1-8.png?fit=max&auto=format&n=mxRp7IkiVukPESZw&q=85&s=1375475f80562a50cf8ecb7e84b45625" alt="AWS API Gateway - Deploy Test Response" width="684" height="339" data-path="docs/images/fr-ca/cdy7uua7fh8z/7d8340OcAtOF8GvBtihRBt/958eff065c665682ef53b9eedae77a8e/aws-pt1-8.png" />
   </Frame>

2. Dans la page **Stages** (Stades), développez l’arbre sous **Test**. Cliquez sur **GET** sous `/pets/{petId}`.

   <Frame>
     <img src="https://mintcdn.com/docs-dev-actions-triggers-prototype/M4OX-dUcWfCOjXvH/docs/images/fr-ca/cdy7uua7fh8z/2QzVCjIndpP9EQ4VUxVzZc/5c2afef3f8c83004b35636557c9ec59e/aws-pt1-9.png?fit=max&auto=format&n=M4OX-dUcWfCOjXvH&q=85&s=4df2d3e74498e0cb169b2144acd4f5ea" alt="AWS API Gateway - Get Pet ID" width="684" height="511" data-path="docs/images/fr-ca/cdy7uua7fh8z/2QzVCjIndpP9EQ4VUxVzZc/5c2afef3f8c83004b35636557c9ec59e/aws-pt1-9.png" />
   </Frame>

3. Vous verrez une **URL Invoke** affichée dans la bannière bleue en haut de la fenêtre. La dernière partie, `{petID}`, représente une variable de chemin. Remplacez cette variable par `1` et accédez la nouvelle URL à l’aide de votre navigateur. Vous devriez recevoir une requête HTTP 200 avec la charge utile JSON suivante :

   ```json lines theme={null}
   {
     "id": 1,
     "type": "dog",
     "price": 249.99
   }
   ```

## Créer les autorisateurs personnalisés

Maintenant que nous disposons d’une API entièrement fonctionnelle gérée par API Gateway, sécurisez cette API afin que seules les personnes disposant de l’autorisation appropriée puissent accéder au back-end derrière l’API.

Utilisez les autorisateurs de requête personnalisés de API Gateway (Passerelle API) pour autoriser vos API à l’aide de stratégies d’autorisation par jeton du porteur, telles que OAuth 2.0 ou SAML. Pour chaque demande entrante, il se produit ce qui suit :

1. API Gateway (Passerelle API) vérifie la présence d’un autorisateur personnalisé correctement configuré.
2. API Gateway (Passerelle API) appelle l’autorisateur personnalisé (qui est une fonction Lambda) avec le jeton d’autorisation.
3. Si le jeton d’autorisation est valide, l’autorisateur personnalisé renvoie les politiques AWS Identity and Access Management (IAM) appropriées.
4. API Gateway (Passerelle API) utilise les politiques renvoyées à l’étape 3 pour autoriser la demande.

### Préparer l’autorisateur personnalisé

Vous pouvez [télécharger un exemple d’autorisateur personnalisé](https://github.com/auth0-samples/jwt-rsa-aws-custom-authorizer) qui prend en charge les jetons émis par Auth0. Par la suite, vous devrez personnaliser les fichiers pour que l’autorisateur personnalisé fonctionne dans votre environnement.

1. Décompressez le dossier contenant les fichiers d’exemple que vous avez téléchargés ci-dessus à l’emplacement de votre choix, et accédez au dossier à l’aide de la ligne de commande.
2. Dans le dossier d’exemple, exécutez `npm install` pour installer les packages Node.js nécessaires au déploiement; AWS exige que ces fichiers soient inclus dans le paquet que vous téléchargerez sur AWS lors d’une étape ultérieure.
3. Configurez votre environnement local avec un fichier `.env`. Vous pouvez copier le fichier `.env.sample` (tout en le renommant `.env`) en utilisant `cp .env.sample .env`. Apportez les modifications suivantes :

| Paramètres         | Valeur                                                                                                                            |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
| **`TOKEN_ISSUER`** | L’émetteur du jeton. Si Auth0 est l’émetteur du jeton, utilisez `https://{yourDomain}/`. Assurez-vous d’inclure la barre oblique. |
| **`JWKS_URI`**     | L’URL du point de terminaison JWKS. Si Auth0 est l’émetteur du jeton, utilisez `https://{yourDomain}/.well-known/jwks.json`       |
| **`AUDIENCE`**     | La valeur de l’**identifiant** de l’API que vous avez créée dans la section Créer une API Auth0 ci-dessus.                        |

À titre d’exemple, le texte de votre fichier `.env` devrait ressembler à ceci une fois terminé :

export const codeExample = `   JWKS_URI=https://{yourDomain}/.well-known/jwks.json
  AUDIENCE=https://your-api-gateway
  TOKEN_ISSUER=https://{yourDomain}/
`;

<AuthCodeBlock children={codeExample} language="text" lines />

### Tester localement l’autorisateur personnalisé

Obtenir un jeton d’accès JWT valide. Il y a plusieurs façons d’en obtenir un et la méthode que vous choisissez dépend du type de votre application, du niveau de confiance ou de l’expérience globale de l’utilisateur final. Pour plus d’informations, consultez [Obtenir des jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/get-access-tokens).

1. Vous pouvez obtenir un jeton de test pour votre API en naviguant vers [Auth0 Dashboard > Applications > API](https://manage.auth0.com/#/apis), en sélectionnant votre API et en sélectionnant **Test**.
2. Créez un fichier local `event.json` contenant le jeton. Vous pouvez copier le fichier d’exemple (exécutez `cp event.json.sample event.json`). Remplacez `ACCESS_TOKEN` par votre jeton JWT et `methodArn` par la valeur ARN appropriée pour la méthode `GET` de votre API.

Pour obtenir `methodArn` :

1. En utilisant la console de la passerelle API, ouvrez l’API **PetStore**.
2. Dans la navigation de gauche, sélectionnez **Resources**.
3. Dans le panneau central **Ressources**, développez l’arborescence des ressources. Sous `/pets`, sélectionnez **GET**.
4. Dans la boîte **Requête de méthode**, vous verrez **ARN**.
5. Exécutez le test en utilisant `npm test`.

lambda-local pour tester l’autorisateur personnalisé en utilisant votre jeton. Si le test a réussi, vous obtiendrez résultat similaire à :

```lines theme={null}
Message
------
{
    "principalId": "C8npTEMVnBrILsBTI91MOh6dfuZbPVAU@clients",
    "policyDocument": {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Action": "execute-api:Invoke",
                "Effect": "Allow",
                "Resource": "arn:aws:execute-api:us-east-1:1234567890:apiId/stage/method/resourcePath"
            }
        ]
    },
    "context": {
        "scope": "FULL_LIST_OF_SCOPES"
    }
}
```

Si la valeur de `Effect` (Effet) est `Allow` (Autoriser), votre authorizer aurait autorisé l’appel à API Gateway (Passerelle API).

Pour en savoir plus, visitez [Lambda-local](https://www.npmjs.com/package/lambda-local) sur NPM.

### Créer le rôle IAM

Le rôle IAM dispose des autorisations requises pour appeler les fonctions Lambda. Avant de pouvoir procéder avec notre autorisateur personnalisé, nous devons créer un rôle IAM qui peut appeler notre autorisateur personnalisé chaque fois que API Gateway (Passerelle API) reçoit une demande d’accès.

1. Connectez-vous à AWS et accédez à la [console IAM](https://console.aws.amazon.com/iam). Dans la navigation de gauche, sélectionnez **Rôles**.

2. Sélectionnez **Créer un nouveau rôle**.

3. Sous **Service AWS**, sélectionnez la ligne **AWS Lambda**, puis **Suivant : Permissions**.

4. Sur l’écran **Attach permissions policy** (Attacher une politique de permissions), sélectionnez **AWSLambdaRole**. Vous pouvez utiliser le filtre fourni pour réduire la liste des options. Sélectionnez **Next: (Suivant) Tags** (Balises), puis sélectionnez **Next:(Suivant) Review** (Réviser) pour continuer.

5. Sur l’écran **Review** (Révision), indiquez un **Role name** (Nom de rôle), tel que `Auth0Integration`. Laissez les autres champs tels quels. Sélectionnez **Create role** (Créer le rôle).

6. Une fois qu’AWS a créé votre rôle, vous serez redirigé vers la page **Roles** (Rôles) d’IAM. Sélectionnez votre nouveau rôle.

7. Sur la page **Résumé** du rôle que vous venez de créer, sélectionnez la vue **Relations de confiance**.

8. Sélectionnez **Edit trust relationship** (Modifier la relation de confiance) et remplissez le champ **Policy Document** (Document de politique) avec l’extrait JSON suivant :

   ```json lines theme={null}
   {
   "Version": "2012-10-17",
   "Statement": [
       {
       "Effect": "Allow",
       "Principal": {
           "Service": [
           "apigateway.amazonaws.com",
           "lambda.amazonaws.com"
           ]
       },
       "Action": "sts:AssumeRole"
       }
   ]
   }
   ```

9. Cliquez sur **Mettre à jour la politique de confiance**.

10. Vous serez redirigé vers la page **Résumé**. Copiez la valeur **Rôle ARN** pour une utilisation ultérieure.

    <Frame>
      <img src="https://mintcdn.com/docs-dev-actions-triggers-prototype/adoBdpzp06Dk41-J/docs/images/fr-ca/cdy7uua7fh8z/1ki5GDOZenh5WRgpbWwzC8/76f415684f08510b4206559032880a59/pt2-10.png?fit=max&auto=format&n=adoBdpzp06Dk41-J&q=85&s=caa423b9d4875567506c1e24d4c25c29" alt="undefined" width="686" height="512" data-path="docs/images/fr-ca/cdy7uua7fh8z/1ki5GDOZenh5WRgpbWwzC8/76f415684f08510b4206559032880a59/pt2-10.png" />
    </Frame>

### Créer la fonction Lambda et déployer l’autorisateur personnalisé

Maintenant que vous avez configuré votre autorisateur personnalisé pour votre environnement et que vous l’avez testé pour voir s’il fonctionne, déployez-le sur AWS.

1. Créez un paquet que vous pouvez télécharger sur AWS en exécutant `npm run paquet`. Cela génère un paquet `custom-authorizer.zip` contenant les modules source, de configuration et de nœud requis par AWS Lambda.
2. Naviguez jusqu’à la [console Lambda](https://console.aws.amazon.com/lambda) et cliquez sur **Create function** (Créer une fonction).
3. Sur la page **Sélectionner le modèle**, cliquez sur **Créer à partir de zéro**pour créer une fonction vierge. Sous **Informations de base**, indiquez les valeurs des paramètres suivants :

| Paramètre       | Valeur                                                         |
| --------------- | -------------------------------------------------------------- |
| **Nom**         | Nom pour votre fonction Lambda, comme `jwtRsaCustomAuthorizer` |
| **Description** | Description pour votre fonction Lambda (facultatif)            |
| **Exécution**   | Sélectionnez `Node.js 10.x`                                    |

4. Cliquez sur **Créer une fonction** pour continuer.
5. Sur la page **Configuration** de votre fonction, descendez jusqu’à la section **Function Code** (Code de la fonction).
6. Sélectionnez **Upload a .ZIP file** (Télécharger un fichier .ZIP) comme **Code entry type** (Type d’entrée de code).
7. Cliquez sur **Télécharger** et sélectionnez le paquet `custom-authorizer.zip` que vous avez créé précédemment.
8. Créez ensuite les trois **Variables d’environnement** suivantes. Notez que ces informations sont identiques à celles du fichier `.env`.

| Parameter          | Value                                                                                                                       |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------- |
| **`TOKEN_ISSUER`** | L’émetteur du jeton. Si Auth0 est l’émetteur du jeton, utilisez `https://{yourDomain}/`                                     |
| **`JWKS_URI`**     | L’URL du point de terminaison JWKS. Si Auth0 est l’émetteur du jeton, utilisez `https://{yourDomain}/.well-known/jwks.json` |
| **`AUDIENCE`**     | La valeur de l’**identifiant** de l’API qu vous créée à l’étape 1.                                                          |

9. Dans la section **Rôle d’exécution**, sélectionnez **Utiliser un rôle existant** puis sélectionnez le rôle IAM que vous avez créé précédemment comme **Rôle existant**.
10. Sous **Paramètres de base**, définissez **Temporisation** sur **30** secondes.
11. Cliquez sur **Enregistrer**.
12. Pour tester la fonction Lambda que vous venez de créer, cliquez sur **Test** dans le coin supérieur droit.
13. Copiez le contenu de votre fichier `event.json` dans le formulaire **Configure test event** (Configurer l’événement de test). Vous pouvez utiliser le modèle d’événement par défaut « Hello World ».
14. Cliquez sur **Créer**.
15. Exécutez votre test en le sélectionnant et en cliquant sur **Test**. Si le test a réussi, vous verrez : « Résultat de l’exécution : succès ». L’agrandissement de la fenêtre de résultat devrait afficher un message similaire à celui que vous avez reçu après la réussite de votre test local.

    <Frame>
      <img src="https://mintcdn.com/docs-dev-actions-triggers-prototype/gqbf-XGz7-Z2BrZ6/docs/images/fr-ca/cdy7uua7fh8z/8Xr9yXq8LwOChAbQkDZlJ/0905bbce96f257716a67376f17a0c975/pt2-19.png?fit=max&auto=format&n=gqbf-XGz7-Z2BrZ6&q=85&s=c025eb8961505754c4a87effa41b3c5e" alt="undefined" width="686" height="512" data-path="docs/images/fr-ca/cdy7uua7fh8z/8Xr9yXq8LwOChAbQkDZlJ/0905bbce96f257716a67376f17a0c975/pt2-19.png" />
    </Frame>

### Configurer l’autorisateur personnalisé de API Gateway (Passerelle API)

1. Retournez à la console API Gateway (Passerelle API) et ouvrez l’API **PetStore** que nous avons créée plus tôt.
2. En utilisant la navigation de gauche, ouvrez **Autorisateurs** et sélectionnez **Créer un nouvel autorisateur**, puis définissez les paramètres suivants et cliquez sur **Créer**.

| Parameter                | Value                                                                       |
| ------------------------ | --------------------------------------------------------------------------- |
| **Name**                 | `jwt-rsa-custom-authorizer`                                                 |
| **Type**                 | Sélectionnez **Lambda**                                                     |
| **Lambda Region**        | Utiliser la région pour la fonction Lambda que vous avez créée précédemment |
| **Lambda Function**      | `jwtRsaCustomAuthorizer`                                                    |
| **Lambda Invoke Role**   | L’ARN du rôle IAM que vous avez copié ci-dessus                             |
| **Lambda Event Payload** | Sélectionnez **Token**                                                      |
| **Token Source**         | `Authorization`                                                             |
| **Token Validation**     | `^Bearer [-0-9a-zA-z\.]*$`                                                  |
| **TTL (seconds)**        | `3600`                                                                      |

3. Une fois qu’AWS a créé l’autorisateur et que la page a été actualisée, testez votre autorisateur en cliquant sur **Test** et en fournissant le jeton Auth0 (`Bearer ey...`) que vous avez utilisé précédemment.
   Si le test a réussi, vous obtiendrez une réponse similaire à la suivante.

   <Frame>
     <img src="https://mintcdn.com/docs-dev-actions-triggers-prototype/AzFg9TUnnX-9tz7j/docs/images/fr-ca/cdy7uua7fh8z/5lx86XsQEJtxVikZJ4lC2C/c2a5c24a31b9cb4b6540267828bbd3a2/pt2-26.png?fit=max&auto=format&n=AzFg9TUnnX-9tz7j&q=85&s=58229aa5176621de05a399622f51a4ea" alt="undefined" width="687" height="513" data-path="docs/images/fr-ca/cdy7uua7fh8z/5lx86XsQEJtxVikZJ4lC2C/c2a5c24a31b9cb4b6540267828bbd3a2/pt2-26.png" />
   </Frame>

## Sécuriser l’API à l’aide d’autorisateurs personnalisés

Pour savoir comment sécuriser les points de terminaison de votre API, consultez l’article du guide du développeur Amazon API Gateway (Passerelle API) : [Utiliser des autorisateurs lambda de passerelle API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html).

### Configurer les ressources API Gateway (Passerelle API) pour utiliser l’autorisateur personnalisé

1. Connectez-vous à AWS et accédez à la [console Passerelle API](http://console.aws.amazon.com/apigateway).

   <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
     Les autorisations personnalisées sont définies méthode par méthode; si vous souhaitez sécuriser plusieurs méthodes à l’aide d’une autorisation unique, vous devrez répéter les instructions suivantes pour chaque méthode.
   </Callout>

2. Ouvrez l’API **PetStore** que nous avons créée à l’étape 2 de ce tutoriel. Dans l’arborescence **Resource** (Ressource) du volet central, sélectionnez la méthode **GET** sous la ressource `/pets`.

   <Frame>
     <img src="https://mintcdn.com/docs-dev-actions-triggers-prototype/M4OX-dUcWfCOjXvH/docs/images/fr-ca/cdy7uua7fh8z/3Z9Gmy20NDr9Hb9Yk0piXF/0c7572fc188e13106d9340562580e5e0/pt3-2.png?fit=max&auto=format&n=M4OX-dUcWfCOjXvH&q=85&s=e012aa51e7e1d28f0ddace908ec58209" alt="undefined" width="685" height="511" data-path="docs/images/fr-ca/cdy7uua7fh8z/3Z9Gmy20NDr9Hb9Yk0piXF/0c7572fc188e13106d9340562580e5e0/pt3-2.png" />
   </Frame>

3. Sélectionnez **Requête de méthode**.

4. Sous **Settings** (Réglages), cliquez sur l’icône **crayon** à droite de **Authorization** (Autorisation) et choisissez l’autorisateur personnalisé `jwt-rsa-custom-authorizer`l’étape 3.

5. Cliquez sur l’icône **de crochet** pour enregistrer votre choix d’autorisateur personnalisé. Assurez-vous que le champ **API Key Required** (Clé API requise) est défini sur `false`.

### Déployer l’API

Pour rendre vos modifications publiques, déployez votre API.

1. Dans le menu **Actions**, sélectionnez **Déployer API**.
2. Indiquez les valeurs suivantes et cliquez sur **Déployer** :

| Paramètre                      | Valeur                           |
| ------------------------------ | -------------------------------- |
| **Étape de déploiement**       | Choisir `[Nouvelle étape]`       |
| **Nom de l’étape**             | Indiquez un nom pour votre étape |
| **Description de l’étape**     | Décrivez votre étape             |
| **Description du déploiement** | Décrivez votre déploiement API   |

En cas de succès, vous serez redirigé vers l’éditeur de développement et de test **Test Stage Editor**. Notez l’**Invoke URL** fournie dans le ruban bleu en haut, car vous en avez besoin pour tester votre déploiement.

## Tester votre déploiement

Pour tester votre déploiement, faites une requête `GET` au **Invoke URL** que vous avez notée à l’étape précédente. Si ce test échoue, vérifiez que vous avez obtenu correctement le jeton d’accès JWT.

Pour plus de détails, voir [Obtenir des jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/get-access-tokens).

<AuthCodeGroup>
  ```bash cURL lines theme={null}
  curl --request GET \
    --url https://%7ByourInvokeUrl%7D/pets
  ```

  ```csharp C# lines theme={null}
  var client = new RestClient("https://%7ByourInvokeUrl%7D/pets");
  var request = new RestRequest(Method.GET);
  IRestResponse response = client.Execute(request);
  ```

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

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

  func main() {

  	url := "https://%7ByourInvokeUrl%7D/pets"

  	req, _ := http.NewRequest("GET", url, nil)

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

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

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

  }
  ```

  ```java Java lines theme={null}
  HttpResponse<String> response = Unirest.get("https://%7ByourInvokeUrl%7D/pets")
    .asString();
  ```

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

  var options = {method: 'GET', url: 'https://%7ByourInvokeUrl%7D/pets'};

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

  ```objc Obj-C lines theme={null}
  #import <Foundation/Foundation.h>

  NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://%7ByourInvokeUrl%7D/pets"]
                                                         cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                     timeoutInterval:10.0];
  [request setHTTPMethod:@"GET"];

  NSURLSession *session = [NSURLSession sharedSession];
  NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                              completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                  if (error) {
                                                      NSLog(@"%@", error);
                                                  } else {
                                                      NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                      NSLog(@"%@", httpResponse);
                                                  }
                                              }];
  [dataTask resume];
  ```

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

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://%7ByourInvokeUrl%7D/pets",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET",
  ]);

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

  curl_close($curl);

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

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

  conn = http.client.HTTPSConnection("")

  conn.request("GET", "%7ByourInvokeUrl%7D/pets")

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

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

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

  url = URI("https://%7ByourInvokeUrl%7D/pets")

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

  request = Net::HTTP::Get.new(url)

  response = http.request(request)
  puts response.read_body
  ```

  ```swift Swift lines theme={null}
  import Foundation

  let request = NSMutableURLRequest(url: NSURL(string: "https://%7ByourInvokeUrl%7D/pets")! as URL,
                                          cachePolicy: .useProtocolCachePolicy,
                                      timeoutInterval: 10.0)
  request.httpMethod = "GET"

  let session = URLSession.shared
  let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
    if (error != nil) {
      print(error)
    } else {
      let httpResponse = response as? HTTPURLResponse
      print(httpResponse)
    }
  })

  dataTask.resume()
  ```
</AuthCodeGroup>