

**Wir stellen vor: ein neues Konsolenerlebnis für AWS WAF**

Sie können das aktualisierte Erlebnis jetzt verwenden, um überall in der Konsole auf AWS WAF Funktionen zuzugreifen. Weitere Informationen finden Sie unter [Arbeiten mit der Konsole](https://docs.aws.amazon.com/waf/latest/developerguide/working-with-console.html). 

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# AWS WAF JavaScript Integrationen
<a name="waf-javascript-api"></a>

In diesem Abschnitt wird erklärt, wie die AWS WAF JavaScript Integrationen verwendet werden.

Sie können die JavaScript Integration verwenden APIs , um AWS WAF Anwendungsintegrationen in Ihren Browsern und anderen Geräten zu implementieren, die ausgeführt werden. JavaScript 

CAPTCHA-Rätsel und stille Herausforderungen können nur ausgeführt werden, wenn Browser auf HTTPS-Endpunkte zugreifen. Browser-Clients müssen in sicheren Kontexten ausgeführt werden, um Token zu erhalten. 
+ Die intelligente Bedrohung ermöglicht APIs es Ihnen, die Token-Autorisierung durch eine stille clientseitige Browser-Abfrage zu verwalten und die Token in die Anfragen aufzunehmen, die Sie an Ihre geschützten Ressourcen senden. 
+ Die CAPTCHA-Integrations-API ergänzt die intelligente Bedrohung und ermöglicht es Ihnen APIs, die Platzierung und die Eigenschaften des CAPTCHA-Puzzles in Ihren Client-Anwendungen anzupassen. Diese API nutzt die intelligente Bedrohung, um AWS WAF Token für die Verwendung auf der Seite APIs zu erwerben, nachdem der Endbenutzer das CAPTCHA-Puzzle erfolgreich gelöst hat. 

Durch die Verwendung dieser Integrationen stellen Sie sicher, dass die Remote-Prozedur-Aufrufe Ihres Clients ein gültiges Token enthalten. Wenn diese Integrationen auf den Seiten Ihrer Anwendung vorhanden APIs sind, können Sie in Ihrem Schutzpaket (Web-ACL) Regeln zur Risikominderung implementieren, z. B. das Blockieren von Anfragen, die kein gültiges Token enthalten. Sie können auch Regeln implementieren, die die Verwendung der Token, die Ihre Client-Anwendungen erhalten, erzwingen, indem Sie die CAPTCHA Aktionen Challenge oder in Ihren Regeln verwenden. 

**Beispiel für die Implementierung einer intelligenten Bedrohung APIs**  
Die folgende Liste zeigt die grundlegenden Komponenten einer typischen Implementierung der intelligenten Bedrohung auf APIs einer Webanwendungsseite. 

```
<head>
<script type="text/javascript" src="protection pack (web ACL) integration URL/challenge.js" defer></script>
</head>
<script>
const login_response = await AwsWafIntegration.fetch(login_url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: login_body
  });
</script>
```

**Beispiel für eine Implementierung der CAPTCHA-API JavaScript**  
Mit der CAPTCHA-Integrations-API können Sie das CAPTCHA-Puzzle-Erlebnis Ihrer Endbenutzer individuell anpassen. Die CAPTCHA-Integration nutzt die JavaScript intelligente Bedrohungsintegration für die Browserverifizierung und die Tokenverwaltung und fügt eine Funktion zur Konfiguration und Darstellung des CAPTCHA-Puzzles hinzu. 

Die folgende Liste zeigt die grundlegenden Komponenten einer typischen Implementierung der JavaScript CAPTCHA-API auf einer Webanwendungsseite. 

```
<head>
    <script type="text/javascript" src="<Integration URL>/jsapi.js" defer></script>
</head>

<script type="text/javascript">
    function showMyCaptcha() {
        var container = document.querySelector("#my-captcha-container");
        
        AwsWafCaptcha.renderCaptcha(container, {
            apiKey: "...API key goes here...",
            onSuccess: captchaExampleSuccessFunction,
            onError: captchaExampleErrorFunction,
            ...other configuration parameters as needed...
        });
    }
    
    function captchaExampleSuccessFunction(wafToken) {
        // Use WAF token to access protected resources
        AwsWafIntegration.fetch("...WAF-protected URL...", {
            method: "POST",
            ...
        });
    }
    
    function captchaExampleErrorFunction(error) {
        /* Do something with the error */
    }
</script>

<div id="my-captcha-container">
    <!-- The contents of this container will be replaced by the captcha widget -->
</div>
```

**Topics**
+ [Bereitstellung von Domains zur Verwendung in den Tokens](waf-js-challenge-api-set-token-domain.md)
+ [Verwenden der JavaScript API mit Inhaltssicherheitsrichtlinien](waf-javascript-api-csp.md)
+ [Verwendung der Intelligent Threat JavaScript API](waf-js-challenge-api.md)
+ [Verwenden der CAPTCHA-API JavaScript](waf-js-captcha-api.md)

# Bereitstellung von Domains zur Verwendung in den Tokens
<a name="waf-js-challenge-api-set-token-domain"></a>

In diesem Abschnitt wird erklärt, wie zusätzliche Domänen für Token bereitgestellt werden.

Bei der Erstellung eines AWS WAF Tokens wird standardmäßig die Hostdomäne der Ressource verwendet, die dem Schutzpaket (Web-ACL) zugeordnet ist. Sie können zusätzliche Domänen für die Token bereitstellen, die für den AWS WAF erstellt JavaScript APIs werden. Konfigurieren Sie dazu die globale Variable `window.awsWafCookieDomainList` mit einer oder mehreren Tokendomänen. 

Bei AWS WAF der Erstellung eines Tokens wird die geeignetste, kürzeste Domain aus der Kombination der Domänen in `window.awsWafCookieDomainList` und der Hostdomäne der Ressource verwendet, die dem Protection Pack (Web-ACL) zugeordnet ist. 

Beispieleinstellungen: 

```
window.awsWafCookieDomainList = ['.aws.amazon.com']
```

```
window.awsWafCookieDomainList = ['.aws.amazon.com', 'abc.aws.amazon.com']
```

Sie können in dieser Liste keine öffentlichen Suffixe verwenden. Beispielsweise können Sie `gov.au` oder nicht `co.uk` als Tokendomänen in der Liste verwenden.

Die Domänen, die Sie in dieser Liste angeben, müssen mit Ihren anderen Domänen und Domänenkonfigurationen kompatibel sein: 
+ Bei den Domains muss es sich um solche handeln, die auf der geschützten Host-Domain und der Token-Domainliste basieren, die für das Protection Pack (Web-ACL) konfiguriert ist. AWS WAF Weitere Informationen finden Sie unter [AWS WAF Konfiguration der Token-Domänenliste für das Protection Pack (Web-ACL)](waf-tokens-domains.md#waf-tokens-domain-lists). 
+ Wenn Sie die JavaScript CAPTCHA-API verwenden, muss mindestens eine Domain in Ihrem CAPTCHA-API-Schlüssel exakt mit einer der Token-Domains in übereinstimmen `window.awsWafCookieDomainList` oder es muss sich um die Apex-Domain einer dieser Token-Domains handeln. 

  Für die Token-Domain `mySubdomain.myApex.com` stimmt der API-Schlüssel beispielsweise exakt überein und der API-Schlüssel `mySubdomain.myApex.com` entspricht der Apex-Domain. `myApex.com` Jeder Schlüssel entspricht der Token-Domain. 

  Weitere Informationen zu den API-Schlüsseln finden Sie unter[Verwaltung von API-Schlüsseln für die JS-CAPTCHA-API](waf-js-captcha-api-key.md). 

Wenn Sie die `AWSManagedRulesACFPRuleSet` verwaltete Regelgruppe verwenden, können Sie eine Domäne konfigurieren, die mit der Domäne im Kontoerstellungspfad übereinstimmt, den Sie für die Regelgruppenkonfiguration angegeben haben. Weitere Informationen zu dieser Konfiguration finden Sie unter [Hinzufügen der verwalteten ACFP-Regelgruppe zu Ihrer Web-ACL](waf-acfp-rg-using.md).

Wenn Sie die `AWSManagedRulesATPRuleSet` verwaltete Regelgruppe verwenden, können Sie eine Domäne konfigurieren, die mit der Domäne im Anmeldepfad übereinstimmt, die Sie für die Regelgruppenkonfiguration angegeben haben. Weitere Informationen zu dieser Konfiguration finden Sie unter [Hinzufügen der von ATP verwalteten Regelgruppe zu Ihrem Protection Pack (Web-ACL)](waf-atp-rg-using.md).

# Verwenden der JavaScript API mit Inhaltssicherheitsrichtlinien
<a name="waf-javascript-api-csp"></a>

Dieser Abschnitt enthält eine Beispielkonfiguration für die Zulassungsliste der AWS WAF Apex-Domain.

Wenn Sie Inhaltssicherheitsrichtlinien (CSP) auf Ihre Ressourcen anwenden, müssen Sie die Apex-Domain auf eine Zulassungsliste setzen, damit Ihre JavaScript Implementierung funktioniert. AWS WAF `awswaf.com` JavaScript SDKs Sie richten Aufrufe an verschiedene AWS WAF Endpunkte, sodass diese Domain auf eine Zulassungsliste gesetzt wird, um die Berechtigungen zu erhalten, die für den Betrieb erforderlich sind. SDKs 

Im Folgenden wird eine Beispielkonfiguration für die Zulassungsliste für die Apex-Domäne gezeigt: AWS WAF 

```
connect-src 'self' https://*.awswaf.com;
script-src 'self' https://*.awswaf.com;
script-src-elem 'self' https://*.awswaf.com;
```

Wenn Sie versuchen, die JavaScript SDKs mit Ressourcen zu verwenden, die CSP verwenden, und Sie die AWS WAF Domain nicht auf die Zulassungsliste gesetzt haben, erhalten Sie Fehlermeldungen wie die folgenden: 

```
Refused to load the script ...awswaf.com/<> because it violates the following Content Security Policy directive: “script-src ‘self’
```

# Verwendung der Intelligent Threat JavaScript API
<a name="waf-js-challenge-api"></a>

Dieser Abschnitt enthält Anweisungen zur Verwendung der Intelligent Threat JavaScript API in Ihrer Client-Anwendung.

Die intelligenten Bedrohungen APIs bieten Operationen für die Ausführung von Anfragen im Hintergrund gegen den Browser des Benutzers und für den Umgang mit AWS WAF Tokens, die den Nachweis erfolgreicher Abfragen und CAPTCHA-Antworten liefern. 

Implementieren Sie die JavaScript Integration zunächst in einer Testumgebung und dann in der Produktion. Weitere Anleitungen zur Codierung finden Sie in den folgenden Abschnitten. 

 

**Um die intelligente Bedrohung zu nutzen APIs**

1. **Installieren Sie das APIs** 

   Wenn Sie die CAPTCHA-API verwenden, können Sie diesen Schritt überspringen. Wenn Sie die CAPTCHA-API installieren, installiert das Skript automatisch die intelligente Bedrohung. APIs

   1. [Melden Sie sich bei homev2 an AWS-Managementkonsole und öffnen Sie die AWS WAF Konsole. https://console.aws.amazon.com/wafv2/](https://console.aws.amazon.com/wafv2/homev2) 

   1. Wählen Sie im Navigationsbereich **Application integration** (Anwendungsintegration) aus. Auf der Seite **zur Anwendungsintegration** finden Sie Optionen in Registerkarten. 

   1. Wählen Sie **Intelligente Bedrohungsintegration**

   1. Wählen Sie auf der Registerkarte das Schutzpaket (Web-ACL) aus, in das Sie integrieren möchten. Die Liste der Schutzpakete (Web-ACL) enthält nur Schutzpakete (Web ACLs), die die `AWSManagedRulesACFPRuleSet` verwaltete Regelgruppe, die `AWSManagedRulesATPRuleSet` verwaltete Regelgruppe oder die gezielte Schutzstufe der `AWSManagedRulesBotControlRuleSet` verwalteten Regelgruppe verwenden. 

   1. Öffnen Sie den **JavaScript SDK-Bereich** und kopieren Sie das Skript-Tag zur Verwendung in Ihrer Integration. 

   1. Fügen Sie im Seitencode Ihrer Anwendung im `<head>` Abschnitt das Skript-Tag ein, das Sie für das Protection Pack (Web-ACL) kopiert haben. Diese Einbeziehung bewirkt, dass Ihre Clientanwendung beim Laden der Seite automatisch ein Token im Hintergrund abruft. 

      ```
      <head>
          <script type="text/javascript" src="protection pack (web ACL) integration URL/challenge.js” defer></script>
      <head>
      ```

      Diese `<script>`-Auflistung wird mit dem `defer`-Attribut konfiguriert, doch Sie können die Einstellung in `async` ändern, wenn sich die Seite auf andere Weise verhalten soll. 

1. **(Optional) Fügen Sie die Domänenkonfiguration für die Token des Clients** hinzu — Beim AWS WAF Erstellen eines Tokens wird standardmäßig die Hostdomäne der Ressource verwendet, die dem Protection Pack (Web-ACL) zugeordnet ist. Folgen Sie den Anweisungen unter JavaScript APIs, um zusätzliche Domänen für bereitzustellen[Bereitstellung von Domains zur Verwendung in den Tokens](waf-js-challenge-api-set-token-domain.md). 

1. **Codieren Sie Ihre intelligente Bedrohungsintegration** — Verfassen Sie Ihren Code, um sicherzustellen, dass der Token-Abruf abgeschlossen ist, bevor der Client seine Anfragen an Ihre geschützten Endgeräte sendet. Wenn Sie für den Aufruf bereits die `fetch`-API verwenden, können Sie den `fetch`-Wrapper der AWS WAF -Integration ersetzen. Wenn Sie die `fetch` API nicht verwenden, können Sie stattdessen den AWS WAF `getToken` Integrationsvorgang verwenden. In den folgenden Abschnitten finden Sie weitere Code-Anweisungen. 

1. **Fügen Sie Ihrem Schutzpaket (Web-ACL) eine Token-Verifizierung** hinzu — Fügen Sie Ihrem Schutzpaket (Web-ACL) mindestens eine Regel hinzu, die in den Webanfragen, die Ihr Client sendet, nach einem gültigen Challenge-Token sucht. Sie können Regelgruppen verwenden, die Challenge-Token überprüfen und überwachen, z. B. die Zielebene der verwalteten Regelgruppe von Bot Control, und Sie können die Challenge Regelaktion zur Überprüfung verwenden, wie unter beschrieben[CAPTCHAund Challenge in AWS WAF](waf-captcha-and-challenge.md). 

   Die Ergänzungen des Protection Packs (Web-ACL) stellen sicher, dass Anfragen an Ihre geschützten Endgeräte das Token enthalten, das Sie in Ihrer Client-Integration erworben haben. Anfragen, die ein gültiges, noch nicht abgelaufenes Token enthalten, bestehen die Challenge Prüfung und stellen keine weitere unbemerkte Aufforderung an Ihren Kunden dar. 

1. **(Optional) Blockieren von Anfragen, bei denen Token fehlen** — Wenn Sie die APIs mit der von ACFP verwalteten Regelgruppe, die von ATP verwaltete Regelgruppe oder die gezielten Regeln der Bot Control-Regelgruppe verwenden, blockieren diese Regeln keine Anfragen, bei denen Token fehlen. Folgen Sie den Anweisungen unter, um Anfragen zu blockieren, bei [Anfragen blockieren, die kein gültiges AWS WAF Token haben](waf-tokens-block-missing-tokens.md) denen Token fehlen. 

**Topics**
+ [API-Spezifikation für intelligente Bedrohungen](waf-js-challenge-api-specification.md)
+ [Wie benutzt man den Integration `fetch` Wrapper](waf-js-challenge-api-fetch-wrapper.md)
+ [Wie benutzt man die Integration `getToken`](waf-js-challenge-api-get-token.md)

# API-Spezifikation für intelligente Bedrohungen
<a name="waf-js-challenge-api-specification"></a>

In diesem Abschnitt sind die Spezifikationen für die Methoden und Eigenschaften der intelligenten Bedrohungsabwehr JavaScript APIs aufgeführt. Verwenden Sie diese APIs für intelligente Bedrohungs- und CAPTCHA-Integrationen.

**`AwsWafIntegration.fetch()`**  
Sendet die `fetch` HTTP-Anfrage mithilfe der Integrationsimplementierung an den AWS WAF Server. 

**`AwsWafIntegration.getToken()`**  
Ruft das gespeicherte AWS WAF Token ab und speichert es in einem Cookie auf der aktuellen Seite mit dem Namen `aws-waf-token` und dem auf den Tokenwert gesetzten Wert. 

**`AwsWafIntegration.hasToken()`**  
Gibt einen booleschen Wert zurück, der angibt, ob das `aws-waf-token` Cookie derzeit ein nicht abgelaufenes Token enthält. 

Wenn Sie auch die CAPTCHA-Integration verwenden, finden Sie die entsprechende Spezifikation unter. [JavaScript CAPTCHA-API-Spezifikation](waf-js-captcha-api-specification.md)

# Wie benutzt man den Integration `fetch` Wrapper
<a name="waf-js-challenge-api-fetch-wrapper"></a>

Dieser Abschnitt enthält Anweisungen zur Verwendung des `fetch` Integrations-Wrappers.

Sie verwenden den AWS WAF `fetch`-Wrapper, indem Sie Ihre regulären `fetch`-Aufrufe in die `fetch`-API unter dem `AwsWafIntegration`-Namespace ändern. Der AWS WAF Wrapper unterstützt dieselben Optionen wie der JavaScript `fetch` Standard-API-Aufruf und fügt die Token-Behandlung für die Integration hinzu. Dieser Ansatz ist im Allgemeinen die einfachste Möglichkeit, Ihre Anwendung zu integrieren. 

**Vor der Wrapper-Implementierung**  
Die folgende Beispielliste zeigt Standardcode vor der Implementierung des `AwsWafIntegration`-`fetch`-Wrapper.

```
const login_response = await fetch(login_url, {
	    method: 'POST',
	    headers: {
	      'Content-Type': 'application/json'
	    },
	    body: login_body
	  });
```

**Nach der Wrapper-Implementierung**  
Die folgende Auflistung zeigt den gleichen Code wie bei der Implementierung des `AwsWafIntegration`-`fetch`-Wrapper.

```
const login_response = await AwsWafIntegration.fetch(login_url, {
	    method: 'POST',
	    headers: {
	      'Content-Type': 'application/json'
	    },
	    body: login_body
	  });
```

# Wie benutzt man die Integration `getToken`
<a name="waf-js-challenge-api-get-token"></a>

In diesem Abschnitt wird erklärt, wie die `getToken` Operation verwendet wird.

AWS WAF erfordert, dass Ihre Anfragen an geschützte Endpunkte das Cookie enthalten, das `aws-waf-token` mit dem Wert Ihres aktuellen Tokens benannt ist. 

Bei der `getToken` Operation handelt es sich um einen asynchronen API-Aufruf, der das AWS WAF Token abruft und es in einem Cookie auf der aktuellen Seite speichert`aws-waf-token`, wobei der Name und der Wert auf den Tokenwert gesetzt sind. Sie können dieses Token-Cookie nach Bedarf auf Ihrer Seite verwenden. 

Wenn Sie `getToken` aufrufen, geschieht Folgendes: 
+ Wenn ein nicht abgelaufenes Token bereits verfügbar ist, gibt der Aufruf es sofort zurück.
+ Andernfalls wird ein neues Token aus dem -Token-Anbieter aufgerufen. Wird der Workflow für den Token-Erwerb nicht innerhalb von 2 Sekunden abgeschlossen, tritt eine Zeitüberschreitung ein. Wenn die Zeitüberschreitung eingetreten ist, wird ein Fehler ausgelöst, der von Ihrem Aufrufcode behoben werden muss. 

Der `getToken`-Betrieb verfügt über den begleitenden `hasToken`-Betrieb, der angibt, ob das `aws-waf-token`-Cookie derzeit ein nicht abgelaufenes Token enthält. 

`AwsWafIntegration.getToken()`ruft ein gültiges Token ab und speichert es als Cookie. Bei den meisten Client-Aufrufen wird dieses Cookie automatisch angehängt, bei einigen jedoch nicht. Bei Aufrufen über Host-Domains hinweg wird das Cookie beispielsweise nicht angehängt. In den folgenden Implementierungsdetails zeigen wir, wie Sie mit beiden Arten von Client-Aufrufen arbeiten können. 

**Grundlegende `getToken` Implementierung für Aufrufe, die das `aws-waf-token` Cookie anhängen**  
Die folgende Beispielliste zeigt Standardcode für die Implementierung des `getToken` Vorgangs mit einer Anmeldeanforderung.

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

**Senden Sie das Formular erst ab, wenn das Token unter `getToken` verfügbar ist.**  
Die folgende Auflistung zeigt, wie Sie einen Ereignis-Listener registrieren, um Formularübermittlungen abzufangen, bis ein gültiges Token zur Verwendung verfügbar ist. 

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

**Anhängen des Tokens, wenn Ihr Client das `aws-waf-token` Cookie nicht standardmäßig anhängt**  
`AwsWafIntegration.getToken()`ruft ein gültiges Token ab und speichert es als Cookie, aber nicht alle Client-Aufrufe hängen dieses Cookie standardmäßig an. Beispielsweise hängen Aufrufe über Hostdomänen hinweg das Cookie nicht an. 

Der `fetch` Wrapper behandelt diese Fälle automatisch, aber wenn Sie den `fetch` Wrapper nicht verwenden können, können Sie dies mithilfe eines benutzerdefinierten `x-aws-waf-token` Headers handhaben. AWS WAF liest Token aus diesem Header und liest sie zusätzlich aus dem `aws-waf-token` Cookie. Der folgende Code zeigt ein Beispiel für das Setzen des Headers. 

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

Akzeptiert standardmäßig AWS WAF nur Token, die dieselbe Domain wie die angeforderte Host-Domain enthalten. Für alle domänenübergreifenden Token sind entsprechende Einträge in der Token-Domainliste des Protection Packs (Web ACL) erforderlich. Weitere Informationen finden Sie unter [AWS WAF Konfiguration der Token-Domänenliste für das Protection Pack (Web-ACL)](waf-tokens-domains.md#waf-tokens-domain-lists). 

Weitere Informationen zur domänenübergreifenden Verwendung von Token finden Sie unter [aws-waf-bot-controlaws-samples/](https://github.com/aws-samples/aws-waf-bot-control-api-protection-with-captcha) -. api-protection-with-captcha

# Verwenden der CAPTCHA-API JavaScript
<a name="waf-js-captcha-api"></a>

Dieser Abschnitt enthält Anweisungen zur Verwendung der CAPTCHA-Integrations-API.

Mit der JavaScript CAPTCHA-API können Sie das CAPTCHA-Puzzle konfigurieren und an der gewünschten Stelle in Ihrer Client-Anwendung platzieren. Diese API nutzt die Funktionen der intelligenten Bedrohung, um AWS WAF Token JavaScript APIs zu erwerben und zu verwenden, nachdem ein Endbenutzer ein CAPTCHA-Puzzle erfolgreich gelöst hat. 

Implementieren Sie die JavaScript Integration zunächst in einer Testumgebung und dann in der Produktion. Weitere Anleitungen zur Codierung finden Sie in den folgenden Abschnitten. 

**Um die CAPTCHA-Integrations-API zu verwenden**

1. **Installieren Sie die API**

   1. Melden Sie sich bei [https://console.aws.amazon.com/wafv2/homev2](https://console.aws.amazon.com/wafv2/homev2) an AWS-Managementkonsole und öffnen Sie die AWS WAF Konsole. 

   1. Wählen Sie im Navigationsbereich **Application integration** (Anwendungsintegration) aus. Auf der Seite **zur Anwendungsintegration** finden Sie Optionen in Registerkarten. 

   1. Wählen Sie **CAPTCHA-Integration** aus.

   1. Kopieren Sie das aufgelistete JavaScript Integrationsskript-Tag zur Verwendung in Ihrer Integration.

   1. Fügen Sie im Code Ihrer Anwendungsseite im `<head>` Abschnitt das Skript-Tag ein, das Sie kopiert haben. Durch diese Aufnahme steht das CAPTCHA-Puzzle zur Konfiguration und Verwendung zur Verfügung. 

      ```
      <head>
          <script type="text/javascript" src="integrationURL/jsapi.js" defer></script>
      </head>
      ```

      Diese `<script>`-Auflistung wird mit dem `defer`-Attribut konfiguriert, doch Sie können die Einstellung in `async` ändern, wenn sich die Seite auf andere Weise verhalten soll. 

      Das CAPTCHA-Skript lädt auch automatisch das intelligente Threat-Integrationsskript, falls es noch nicht vorhanden ist. Das Skript zur intelligenten Bedrohungsintegration veranlasst Ihre Client-Anwendung, beim Laden der Seite automatisch ein Token im Hintergrund abzurufen, und bietet weitere Funktionen zur Tokenverwaltung, die Sie für die Verwendung der CAPTCHA-API benötigen. 

1. **(Optional) Fügen Sie die Domänenkonfiguration für die Token des Clients** hinzu — Standardmäßig AWS WAF wird bei der Erstellung eines Tokens die Hostdomäne der Ressource verwendet, die dem Protection Pack (Web-ACL) zugeordnet ist. Folgen Sie den Anweisungen unter JavaScript APIs, um zusätzliche Domänen für bereitzustellen[Bereitstellung von Domains zur Verwendung in den Tokens](waf-js-challenge-api-set-token-domain.md). 

1. **Holen Sie sich den verschlüsselten API-Schlüssel für den Client** — Die CAPTCHA-API benötigt einen verschlüsselten API-Schlüssel, der eine Liste gültiger Kundendomänen enthält. AWS WAF verwendet diesen Schlüssel, um zu überprüfen, ob die Client-Domain, die Sie mit der Integration verwenden, für die Verwendung AWS WAF von CAPTCHA zugelassen ist. Folgen Sie den Anweisungen unter, um Ihren API-Schlüssel zu generieren. [Verwaltung von API-Schlüsseln für die JS-CAPTCHA-API](waf-js-captcha-api-key.md)

1. **Codieren Sie Ihre CAPTCHA-Widget-Implementierung** — Implementieren Sie den `renderCaptcha()` API-Aufruf auf Ihrer Seite an der Stelle, an der Sie ihn verwenden möchten. Informationen zur Konfiguration und Verwendung dieser Funktion finden Sie in den folgenden Abschnitten und. [JavaScript CAPTCHA-API-Spezifikation](waf-js-captcha-api-specification.md) [Wie rendert man das CAPTCHA-Puzzle](waf-js-captcha-api-render.md) 

   Die CAPTCHA-Implementierung integriert sich in die intelligente Bedrohungsintegration APIs für die Tokenverwaltung und die Ausführung von Abruf-Aufrufen, die die Token verwenden. AWS WAF Anleitungen zu deren APIs Verwendung finden Sie unter. [Verwendung der Intelligent Threat JavaScript API](waf-js-challenge-api.md)

1. **Fügen Sie Ihrem Schutzpaket (Web-ACL) eine Token-Verifizierung** hinzu — Fügen Sie Ihrem Schutzpaket (Web-ACL) mindestens eine Regel hinzu, die überprüft, ob in den von Ihrem Client gesendeten Webanfragen ein gültiges CAPTCHA-Token vorhanden ist. Sie können die CAPTCHA Regelaktion zur Überprüfung verwenden, wie unter beschrieben. [CAPTCHAund Challenge in AWS WAF](waf-captcha-and-challenge.md) 

   Die Ergänzungen des Protection Packs (Web-ACL) stellen sicher, dass Anfragen, die an Ihre geschützten Endgeräte gesendet werden, das Token enthalten, das Sie in Ihrer Client-Integration erworben haben. Anfragen, die ein gültiges, noch nicht abgelaufenes CAPTCHA-Token enthalten, bestehen die Prüfung der CAPTCHA Regelaktion und stellen Ihren Endbenutzer nicht vor ein weiteres CAPTCHA-Rätsel. 

Nachdem Sie die JavaScript API implementiert haben, können Sie die CloudWatch Metriken für CAPTCHA-Rätselversuche und -lösungen überprüfen. Einzelheiten zu Metriken und Dimensionen finden Sie unter. [Kennzahlen und Dimensionen Ihres Kontos](waf-metrics.md#waf-metrics-account)

**Topics**
+ [JavaScript CAPTCHA-API-Spezifikation](waf-js-captcha-api-specification.md)
+ [Wie rendert man das CAPTCHA-Puzzle](waf-js-captcha-api-render.md)
+ [Umgang mit einer CAPTCHA-Antwort von AWS WAF](waf-js-captcha-api-conditional.md)
+ [Verwaltung von API-Schlüsseln für die JS-CAPTCHA-API](waf-js-captcha-api-key.md)

# JavaScript CAPTCHA-API-Spezifikation
<a name="waf-js-captcha-api-specification"></a>

In diesem Abschnitt sind die Spezifikationen für die Methoden und Eigenschaften des CAPTCHA aufgeführt. JavaScript APIs Verwenden Sie das CAPTCHA, JavaScript APIs um benutzerdefinierte CAPTCHA-Rätsel in Ihren Client-Anwendungen auszuführen. 

Diese API basiert auf der intelligenten Bedrohung APIs, mit der Sie die Erfassung und Verwendung von AWS WAF Token konfigurieren und verwalten. Siehe[API-Spezifikation für intelligente Bedrohungen](waf-js-challenge-api-specification.md).

**`AwsWafCaptcha.renderCaptcha(container, configuration)`**  
Präsentiert dem Endbenutzer ein AWS WAF CAPTCHA-Puzzle und aktualisiert bei Erfolg das Client-Token mit der CAPTCHA-Validierung. Dies ist nur mit der CAPTCHA-Integration verfügbar. Verwenden Sie diesen Anruf zusammen mit der intelligenten Bedrohung APIs , um den Token-Abruf zu verwalten und das Token in Ihren Anrufen bereitzustellen. `fetch` Die intelligente Bedrohung finden Sie APIs unter. [API-Spezifikation für intelligente Bedrohungen](waf-js-challenge-api-specification.md)  
Im Gegensatz zum CAPTCHA-Interstitial, das AWS WAF gesendet wird, zeigt das mit dieser Methode gerenderte CAPTCHA-Puzzle das Rätsel sofort an, ohne dass ein anfänglicher Titelbildschirm angezeigt wird.     
**`container`**  
Das `Element` Objekt für das Zielcontainerelement auf der Seite. Dies wird üblicherweise durch Aufrufen von `document.getElementById()` oder abgerufen`document.querySelector()`.  
Erforderlich: Ja  
Typ: `Element`  
**Konfiguration**  
Ein Objekt, das CAPTCHA-Konfigurationseinstellungen wie folgt enthält: ****    
**`apiKey`**   
Der verschlüsselte API-Schlüssel, der Berechtigungen für die Domäne des Kunden aktiviert. Verwenden Sie die AWS WAF Konsole, um Ihre API-Schlüssel für Ihre Kundendomänen zu generieren. Sie können einen Schlüssel für bis zu fünf Domains verwenden. Weitere Informationen finden Sie unter [Verwaltung von API-Schlüsseln für die JS-CAPTCHA-API](waf-js-captcha-api-key.md).   
Erforderlich: Ja  
Typ: `string`  
**`onSuccess: (wafToken: string) => void;`**   
Wird mit einem gültigen AWS WAF Token aufgerufen, wenn der Endbenutzer ein CAPTCHA-Rätsel erfolgreich gelöst hat. Verwenden Sie das Token in den Anfragen, die Sie an die Endgeräte senden, die Sie mit einem AWS WAF Schutzpaket (Web-ACL) schützen. Das Token liefert den Nachweis und den Zeitstempel für die letzte erfolgreiche Lösung des Rätsels.   
Erforderlich: Ja  
**`onError?: (error: CaptchaError) => void;`**   
Wird mit einem Fehlerobjekt aufgerufen, wenn während der CAPTCHA-Operation ein Fehler auftritt.   
Erforderlich: Nein  
**`CaptchaError`Klassendefinition** — Der `onError` Handler liefert einen Fehlertyp mit der folgenden Klassendefinition.   

```
CaptchaError extends Error {
    kind: "internal_error" | "network_error" | "token_error" | "client_error";
    statusCode?: number;
}
```
+ `kind`— Die Art des zurückgegebenen Fehlers. 
+ `statusCode`— Der HTTP-Statuscode, falls verfügbar. Dieser wird verwendet, `network_error` wenn der Fehler auf einen HTTP-Fehler zurückzuführen ist.  
**`onLoad?: () => void;`**   
Wird aufgerufen, wenn ein neues CAPTCHA-Rätsel geladen wird.  
Erforderlich: Nein  
**`onPuzzleTimeout?: () => void;`**   
Wird aufgerufen, wenn ein CAPTCHA-Rätsel nicht gelöst wird, bevor es abläuft.  
Erforderlich: Nein  
**`onPuzzleCorrect?: () => void;`**   
Wird aufgerufen, wenn eine richtige Antwort auf ein CAPTCHA-Rätsel gegeben wurde.  
Erforderlich: Nein  
**`onPuzzleIncorrect?: () => void;`**   
Wird aufgerufen, wenn eine falsche Antwort auf ein CAPTCHA-Rätsel gegeben wird.  
Erforderlich: Nein  
**`defaultLocale`**   
Das Standard-Gebietsschema, das für das CAPTCHA-Rätsel verwendet werden soll. Die schriftlichen Anweisungen für CAPTCHA-Rätsel sind in Arabisch (ar-SA), vereinfachtem Chinesisch (zh-CN), Niederländisch (nl-NL), Englisch (en-US), Französisch (fr-FR), Deutsch (de-DE), Italienisch (it-IT), Japanisch (ja-JP), Portugiesisch (pt-BR), Spanisch (es-ES) und Türkisch (tr-TR) verfügbar. Audioanweisungen sind für alle Schriftsprachen verfügbar, mit Ausnahme von Chinesisch und Japanisch, für die standardmäßig Englisch verwendet wird. Um die Standardsprache zu ändern, geben Sie die internationale Sprache und den Ländercode an, `ar-SA` z. B.  
Standard: Die Sprache, die derzeit im Browser des Endbenutzers verwendet wird  
Erforderlich: Nein  
Typ: `string`  
**`disableLanguageSelector`**   
Wenn auf gesetzt`true`, verbirgt das CAPTCHA-Puzzle die Sprachauswahl.   
Standard: `false`  
Erforderlich: Nein  
Typ: `boolean`  
**`dynamicWidth`**   
Wenn auf gesetzt`true`, ändert das CAPTCHA-Puzzle aus Gründen der Kompatibilität mit der Breite des Browserfensters seine Breite.   
Standard: `false`  
Erforderlich: Nein  
Typ: `boolean`  
**`skipTitle`**   
**Wenn diese Option auf gesetzt ist`true`, zeigt das CAPTCHA-Puzzle nicht die Überschrift Löse das Rätsel an.**   
Standard: `false`  
Erforderlich: Nein  
Typ: `boolean`

# Wie rendert man das CAPTCHA-Puzzle
<a name="waf-js-captcha-api-render"></a>

Dieser Abschnitt enthält eine `renderCaptcha` Beispielimplementierung.

Sie können den AWS WAF `renderCaptcha` Aufruf an der gewünschten Stelle in Ihrer Client-Schnittstelle verwenden. Der Aufruf ruft ein CAPTCHA-Puzzle ab AWS WAF, rendert es und sendet die Ergebnisse zur Überprüfung an. AWS WAF Wenn Sie den Aufruf tätigen, geben Sie die Konfiguration für das Rendern von Rätseln und die Callbacks an, die Sie ausführen möchten, wenn Ihre Endbenutzer das Rätsel gelöst haben. Einzelheiten zu den Optionen finden Sie im vorherigen Abschnitt,[JavaScript CAPTCHA-API-Spezifikation](waf-js-captcha-api-specification.md).

Verwenden Sie diesen Aufruf in Verbindung mit der Token-Management-Funktionalität der Intelligent Threat Integration APIs. Durch diesen Aufruf erhält Ihr Kunde ein Token, das den erfolgreichen Abschluss des CAPTCHA-Rätsels bestätigt. Verwenden Sie die intelligente Bedrohungsintegration APIs , um das Token zu verwalten und das Token in den Aufrufen Ihres Kunden an die Endgeräte bereitzustellen, die mit AWS WAF Schutzpaketen geschützt sind (Web). ACLs Informationen zur intelligenten Bedrohung finden Sie APIs unter[Verwendung der Intelligent Threat JavaScript API](waf-js-challenge-api.md).

**Beispielimplementierung**  
Die folgende Beispielliste zeigt eine standardmäßige CAPTCHA-Implementierung, einschließlich der Platzierung der AWS WAF Integrations-URL im `<head>` Abschnitt. 

In dieser Auflistung wird die `renderCaptcha` Funktion mit einem erfolgreichen Callback konfiguriert, der den `AwsWafIntegration.fetch` Wrapper der Intelligent Threat Integration verwendet. APIs Hinweise zu dieser Funktion finden Sie unter. [Wie benutzt man den Integration `fetch` Wrapper](waf-js-challenge-api-fetch-wrapper.md)

```
<head>
    <script type="text/javascript" src="<Integration URL>/jsapi.js" defer></script>
</head>

<script type="text/javascript">
    function showMyCaptcha() {
        var container = document.querySelector("#my-captcha-container");
        
        AwsWafCaptcha.renderCaptcha(container, {
            apiKey: "...API key goes here...",
            onSuccess: captchaExampleSuccessFunction,
            onError: captchaExampleErrorFunction,
            ...other configuration parameters as needed...
        });
    }
    
    function captchaExampleSuccessFunction(wafToken) {
        // Captcha completed. wafToken contains a valid WAF token. Store it for
        // use later or call AwsWafIntegration.fetch() to use it easily.
        // It will expire after a time, so calling AwsWafIntegration.getToken()
        // again is advised if the token is needed later on, outside of using the
        // fetch wrapper.
        
        // Use WAF token to access protected resources
        AwsWafIntegration.fetch("...WAF-protected URL...", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
            },
            body: "{ ... }" /* body content */
        });
    }
    
    function captchaExampleErrorFunction(error) {
        /* Do something with the error */
    }
</script>

<div id="my-captcha-container">
    <!-- The contents of this container will be replaced by the captcha widget -->
</div>
```

**Beispiel für Konfigurationseinstellungen**  
Die folgende Beispielliste zeigt die Optionen `renderCaptcha` mit nicht standardmäßigen Einstellungen für die Breite und den Titel. 

```
        AwsWafCaptcha.renderCaptcha(container, {
            apiKey: "...API key goes here...",
            onSuccess: captchaExampleSuccessFunction,
            onError: captchaExampleErrorFunction,
            dynamicWidth: true, 
            skipTitle: true
        });
```

Vollständige Informationen zu den Konfigurationsoptionen finden Sie unter[JavaScript CAPTCHA-API-Spezifikation](waf-js-captcha-api-specification.md).

# Umgang mit einer CAPTCHA-Antwort von AWS WAF
<a name="waf-js-captcha-api-conditional"></a>

Dieser Abschnitt enthält ein Beispiel für den Umgang mit einer CAPTCHA-Antwort.

Eine AWS WAF Regel mit einer CAPTCHA Aktion beendet die Auswertung einer passenden Webanfrage, wenn die Anfrage kein Token mit einem gültigen CAPTCHA-Zeitstempel hat. Handelt es sich bei der Anfrage um einen `GET` text/html Anruf, wird dem Client durch die CAPTCHA Aktion ein Interstitial mit einem CAPTCHA-Rätsel angezeigt. Wenn Sie die JavaScript CAPTCHA-API nicht integrieren, führt das Interstitial das Rätsel aus. Wenn der Endbenutzer es erfolgreich löst, wird die Anfrage automatisch erneut gesendet. 

Wenn Sie die JavaScript CAPTCHA-API integrieren und Ihre CAPTCHA-Handhabung anpassen, müssen Sie die abschließende CAPTCHA-Antwort erkennen, Ihr benutzerdefiniertes CAPTCHA bereitstellen und dann, wenn der Endbenutzer das Rätsel erfolgreich löst, die Webanfrage des Kunden erneut einreichen. 

Das folgende Codebeispiel veranschaulicht, wie dazu vorgegangen wird. 

**Anmerkung**  
Die AWS WAF CAPTCHA Aktionsantwort hat den Statuscode HTTP 405, anhand dessen wir die Antwort in diesem Code erkennen. CAPTCHA Wenn Ihr geschützter Endpunkt einen HTTP 405-Statuscode verwendet, um eine andere Art von Antwort für denselben Anruf zu übermitteln, wird mit diesem Beispielcode auch für diese Antworten ein CAPTCHA-Rätsel erstellt. 

```
<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript" src="<Integration URL>/jsapi.js" defer></script>
</head>
<body>
    <div id="my-captcha-box"></div>
    <div id="my-output-box"></div>

    <script type="text/javascript">
    async function loadData() {
        // Attempt to fetch a resource that's configured to trigger a CAPTCHA
        // action if the rule matches. The CAPTCHA response has status=HTTP 405.
        const result = await AwsWafIntegration.fetch("/protected-resource");

        // If the action was CAPTCHA, render the CAPTCHA and return

        // NOTE: If the endpoint you're calling in the fetch call responds with HTTP 405
        // as an expected response status code, then this check won't be able to tell the
        // difference between that and the CAPTCHA rule action response.

        if (result.status === 405) {
            const container = document.querySelector("#my-captcha-box");
            AwsWafCaptcha.renderCaptcha(container, {
                apiKey: "...API key goes here...",
                onSuccess() {
                    // Try loading again, now that there is a valid CAPTCHA token
                    loadData();
                },
            });
            return;
        }

        const container = document.querySelector("#my-output-box");
        const response = await result.text();
        container.innerHTML = response;
    }

    window.addEventListener("load", () => {
        loadData();
    });
    </script>
</body>
</html>
```

# Verwaltung von API-Schlüsseln für die JS-CAPTCHA-API
<a name="waf-js-captcha-api-key"></a>

Dieser Abschnitt enthält Anweisungen zum Generieren und Löschen von API-Schlüsseln.

Um AWS WAF CAPTCHA mit der JavaScript API in eine Client-Anwendung zu integrieren, benötigen Sie das API-Integrations-Tag und den verschlüsselten JavaScript API-Schlüssel für die Client-Domain, in der Sie Ihr CAPTCHA-Puzzle ausführen möchten. 

Die CAPTCHA-Anwendungsintegration für JavaScript verwendet die verschlüsselten API-Schlüssel, um zu überprüfen, ob die Domäne der Client-Anwendung berechtigt ist, die CAPTCHA-API zu verwenden. AWS WAF Wenn Sie die CAPTCHA-API von Ihrem JavaScript Client aus aufrufen, geben Sie einen API-Schlüssel mit einer Domainliste an, die eine Domain für den aktuellen Client enthält. Sie können bis zu 5 Domains in einem einzigen verschlüsselten Schlüssel auflisten. 

**Anforderungen an API-Schlüssel**  
Der API-Schlüssel, den Sie in Ihrer CAPTCHA-Integration verwenden, muss eine Domain enthalten, die für den Client gilt, auf dem Sie den Schlüssel verwenden. 
+ Wenn Sie `window.awsWafCookieDomainList` in der intelligenten Bedrohungsintegration Ihres Kunden eine angeben, muss mindestens eine Domain in Ihrem API-Schlüssel exakt mit einer der Token-Domains in übereinstimmen `window.awsWafCookieDomainList` oder es muss sich um die Apex-Domain einer dieser Token-Domains handeln. 

  Für die Token-Domain `mySubdomain.myApex.com` entspricht der API-Schlüssel `mySubdomain.myApex.com` beispielsweise exakt und der API-Schlüssel `myApex.com` der Apex-Domain. Jeder Schlüssel entspricht der Token-Domain. 

  Hinweise zur Einstellung der Tokendomänenliste finden Sie unter[Bereitstellung von Domains zur Verwendung in den Tokens](waf-js-challenge-api-set-token-domain.md).
+ Andernfalls muss die aktuelle Domain im API-Schlüssel enthalten sein. Die aktuelle Domain ist die Domain, die Sie in der Adressleiste des Browsers sehen können. 

Basierend auf der geschützten Host-Domain und der Token-Domainliste, die für die Web-ACL konfiguriert ist, müssen die verwendeten Domains akzeptiert werden. AWS WAF Weitere Informationen finden Sie unter [AWS WAF Konfiguration der Token-Domänenliste für das Protection Pack (Web-ACL)](waf-tokens-domains.md#waf-tokens-domain-lists).

**Wie wählen Sie die Region für Ihren API-Schlüssel**  
AWS WAF kann CAPTCHA-API-Schlüssel in jeder Region generieren, in der sie verfügbar AWS WAF sind. 

In der Regel sollten Sie für Ihren CAPTCHA-API-Schlüssel dieselbe Region verwenden wie für Ihr Schutzpaket (Web-ACL). Wenn Sie jedoch erwarten, dass ein regionales Schutzpaket (Web-ACL) von einem globalen Publikum verwendet wird, können Sie ein JavaScript CAPTCHA-Integrations-Tag mit Gültigkeitsbereich CloudFront und einen API-Schlüssel mit Gültigkeitsbereich abrufen und diese zusammen mit einem regionalen Schutzpaket (Web-ACL) verwenden. CloudFront Dieser Ansatz ermöglicht es Kunden, ein CAPTCHA-Puzzle aus der Region zu laden, die ihnen am nächsten ist, wodurch die Latenz reduziert wird. 

CAPTCHA-API-Schlüssel, die auf andere Regionen beschränkt sind, werden nicht für die Verwendung in CloudFront mehreren Regionen unterstützt. Sie können nur in der Region verwendet werden, auf die sie beschränkt sind. 

**Um einen API-Schlüssel für Ihre Kundendomänen zu generieren**  
Um die Integrations-URL abzurufen und die API-Schlüssel über die Konsole zu generieren und abzurufen. 

1. Melden Sie sich bei [https://console.aws.amazon.com/wafv2/homev2](https://console.aws.amazon.com/wafv2/homev2) an AWS-Managementkonsole und öffnen Sie die AWS WAF Konsole. 

1. Wählen Sie im Navigationsbereich **Application integration** (Anwendungsintegration) aus. 

1. Wählen Sie im Bereich **Schutzpakete (Web ACLs), die für die Anwendungsintegration aktiviert sind**, die Region aus, die Sie für Ihren API-Schlüssel verwenden möchten. Sie können die Region auch im Bereich **API-Schlüssel** auf der Registerkarte **CAPTCHA-Integration** auswählen.

1. Wählen Sie den Tab **CAPTCHA-Integration**. Auf dieser Registerkarte finden Sie das JavaScript CAPTCHA-Integrations-Tag, das Sie in Ihrer Integration verwenden können, sowie die Liste der API-Schlüssel. Beide sind auf die ausgewählte Region beschränkt.

1. Wählen Sie im Bereich **API-Schlüssel** die Option Schlüssel **generieren** aus. Der Dialog zur Schlüsselgenerierung wird angezeigt. 

1. Geben Sie die Client-Domänen ein, die Sie in den Schlüssel aufnehmen möchten. Sie können bis zu 5 eingeben. Wenn Sie fertig sind, wählen Sie **Schlüssel generieren**. Die Benutzeroberfläche kehrt zur Registerkarte CAPTCHA-Integration zurück, auf der Ihr neuer Schlüssel aufgeführt ist. 

   Einmal erstellt, ist ein API-Schlüssel unveränderlich. Wenn Sie Änderungen an einem Schlüssel vornehmen müssen, generieren Sie einen neuen Schlüssel und verwenden Sie ihn stattdessen. 

1. (Optional) Kopieren Sie den neu generierten Schlüssel zur Verwendung in Ihrer Integration. 

Sie können AWS SDKs für diese Arbeit auch den REST APIs oder eine der sprachspezifischen Sprachen verwenden. [Die REST-API-Aufrufe lauten [Create APIKey und List](https://docs.aws.amazon.com/waf/latest/APIReference/API_CreateAPIKey.html). APIKeys](https://docs.aws.amazon.com/waf/latest/APIReference/API_ListAPIKeys.html) 

**So löschen Sie einen API-Schlüssel**  
Um einen API-Schlüssel zu löschen, müssen Sie die REST-API oder eine der sprachspezifischen APIs verwenden AWS SDKs. Der REST-API-Aufruf lautet [Delete APIKey](https://docs.aws.amazon.com/waf/latest/APIReference/API_DeleteAPIKey.html). Sie können die Konsole nicht verwenden, um einen Schlüssel zu löschen. 

Nachdem Sie einen Schlüssel gelöscht haben, kann es bis zu 24 Stunden dauern, AWS WAF bis die Verwendung des Schlüssels in allen Regionen nicht mehr zulässig ist. 