

**Présentation d'une nouvelle expérience de console pour AWS WAF**

Vous pouvez désormais utiliser l'expérience mise à jour pour accéder aux AWS WAF fonctionnalités n'importe où dans la console. Pour plus de détails, consultez la section [Utilisation de la console](https://docs.aws.amazon.com/waf/latest/developerguide/working-with-console.html). 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Comment utiliser l'intégration `getToken`
<a name="waf-js-challenge-api-get-token"></a>

Cette section explique comment utiliser cette `getToken` opération.

AWS WAF nécessite que vos demandes adressées aux points de terminaison protégés incluent le cookie nommé `aws-waf-token` avec la valeur de votre jeton actuel. 

L'`getToken`opération est un appel d'API asynchrone qui récupère le AWS WAF jeton et le stocke dans un cookie sur la page en cours avec un nom `aws-waf-token` et une valeur définie sur la valeur du jeton. Vous pouvez utiliser ce cookie symbolique selon vos besoins sur votre page. 

Lorsque vous appelez`getToken`, il effectue les opérations suivantes : 
+ Si un jeton non expiré est déjà disponible, l'appel le renvoie immédiatement.
+ Dans le cas contraire, l'appel récupère un nouveau jeton auprès du fournisseur de jetons, en attendant jusqu'à 2 secondes que le flux de travail d'acquisition de jetons soit terminé avant l'expiration du délai imparti. Si l'opération expire, elle génère une erreur que votre code d'appel doit gérer. 

L'`getToken`opération est accompagnée d'une `hasToken` opération qui indique si le `aws-waf-token` cookie contient actuellement un jeton non expiré. 

`AwsWafIntegration.getToken()`récupère un jeton valide et le stocke sous forme de cookie. La plupart des appels clients joignent automatiquement ce cookie, mais ce n'est pas le cas pour certains. Par exemple, les appels passés entre des domaines hôtes ne joignent pas le cookie. Dans les détails de mise en œuvre qui suivent, nous montrons comment travailler avec les deux types d'appels clients. 

**`getToken`Implémentation de base, pour les appels qui joignent le `aws-waf-token` cookie**  
L'exemple de liste suivant montre le code standard pour implémenter l'`getToken`opération avec une demande de connexion.

```
const login_response = await AwsWafIntegration.getToken()
	    .catch(e => {
	        // Implement error handling logic for your use case
	    })
	    // The getToken call returns the token, and doesn't typically require special handling
	    .then(token => {
	        return loginToMyPage()
	    })
	
	async function loginToMyPage() {
	    // Your existing login code
	}
```

**Soumettre le formulaire uniquement une fois que le jeton sera disponible auprès de `getToken`**  
La liste suivante indique comment enregistrer un écouteur d'événements pour intercepter les soumissions de formulaires jusqu'à ce qu'un jeton valide soit disponible pour utilisation. 

```
<body>
	  <h1>Login</h1>
	  <p></p>
	  <form id="login-form" action="/web/login" method="POST" enctype="application/x-www-form-urlencoded">
	    <label for="input_username">USERNAME</label>
	    <input type="text" name="input_username" id="input_username"><br>
	    <label for="input_password">PASSWORD</label>
	    <input type="password" name="input_password" id="input_password"><br>
	    <button type="submit">Submit<button>
	  </form>
	
	<script>
	  const form = document.querySelector("#login-form");
	
	  // Register an event listener to intercept form submissions
	  form.addEventListener("submit", (e) => {
	      // Submit the form only after a token is available 
	      if (!AwsWafIntegration.hasToken()) {
	          e.preventDefault();
	          AwsWafIntegration.getToken().then(() => {
	              e.target.submit();
	          }, (reason) => { console.log("Error:"+reason) });
	        }
	    });
	</script>
	</body>
```

**Joindre le jeton lorsque votre client n'attache pas le `aws-waf-token` cookie par défaut**  
`AwsWafIntegration.getToken()`récupère un jeton valide et le stocke sous forme de cookie, mais tous les appels clients ne joignent pas ce cookie par défaut. Par exemple, les appels passés entre des domaines hôtes ne joignent pas le cookie. 

Le `fetch` wrapper gère ces cas automatiquement, mais si vous n'êtes pas en mesure d'utiliser le `fetch` wrapper, vous pouvez le faire en utilisant un en-tête personnalisé`x-aws-waf-token`. AWS WAF lit les jetons depuis cet en-tête, en plus de les lire depuis le `aws-waf-token` cookie. Le code suivant montre un exemple de définition de l'en-tête. 

```
const token = await AwsWafIntegration.getToken();
const result = await fetch('/url', {
    headers: {
        'x-aws-waf-token': token,
    },
});
```

Par défaut, AWS WAF n'accepte que les jetons contenant le même domaine que le domaine hôte demandé. Tous les jetons interdomaines nécessitent des entrées correspondantes dans la liste des domaines des jetons du pack de protection (ACL Web). Pour de plus amples informations, veuillez consulter [AWS WAF configuration de la liste de domaines de jetons du pack de protection (ACL Web)](waf-tokens-domains.md#waf-tokens-domain-lists). 

Pour plus d'informations sur l'utilisation de jetons entre domaines, consultez [aws-waf-bot-controlaws-samples/](https://github.com/aws-samples/aws-waf-bot-control-api-protection-with-captcha) -. api-protection-with-captcha