

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

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