

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 von Canary-Vorlagen
<a name="CloudWatch_Synthetics_Canaries_Blueprints"></a>

Dieser Abschnitt enthält Details zu den jeweiligen Canary-Vorlagen und zu den Aufgaben, für die jede Vorlage am besten geeignet ist. Vorlagen werden für die folgenden Canary-Arten bereitgestellt: 

**Topics**
+ [Heartbeat-Überwachung](#CloudWatch_Synthetics_Canaries_Blueprints_Heartbeat)
+ [API-Canary](#CloudWatch_Synthetics_Canaries_Blueprints_API)
+ [Broken Link Checker](#CloudWatch_Synthetics_Canaries_Blueprints_Broken_Links)
+ [Blueprint für die visuelle Überwachung](#CloudWatch_Synthetics_Canaries_Blueprints_VisualTesting)
+ [Canary-Recorder](#CloudWatch_Synthetics_Canaries_Blueprints_Recorder)
+ [GUI Workflow Builder](#CloudWatch_Synthetics_Canaries_Blueprints_GUI_Workflow)
+ [Blueprint für mehrere Prüfungen](#CloudWatch_Synthetics_Canaries_Blueprints_Multichecks_Blueprint)
+ [Blueprint Canary für mehrere Checks erstellen](CloudWatch_Synthetics_Canaries_MultiCheck_Blueprint.md)

Wenn Sie eine Vorlage zum Erstellen eines Canary verwenden und die Felder in der CloudWatch-Konsole ausfüllen, wird im Bereich **Script editor (Skript-Editor)** der Seite das Canary, das Sie erstellen, als Node.js-Skript angezeigt. Sie können Ihr Canary in diesem Bereich auch bearbeiten, um es weiter anzupassen.

## Heartbeat-Überwachung
<a name="CloudWatch_Synthetics_Canaries_Blueprints_Heartbeat"></a>

Über Heartbeat-Skripte werden die angegebene URL geladen und ein Screenshot der Seite sowie eine HTTP-Archivdatei (HAR-Datei) gespeichert. Sie speichern auch Protokolle der Zugriffe. URLs 

Sie können die HAR-Dateien verwenden, um sich detaillierte Leistungsdaten über die Webseiten anzeigen zu lassen. Sie können die Liste der Web-Anforderungen analysieren und Performance-Probleme wie die Ladezeit für ein Element erfassen.

Wenn dein Canary die Runtime-Version `syn-nodejs-puppeteer-3.1` oder eine neuere Version verwendet, kannst du den Heartbeat-Monitoring-Blueprint verwenden, um mehrere URLs zu überwachen URLs und dir den Status, die Dauer, die zugehörigen Screenshots und die Fehlerursache für jede URL in der Schrittzusammenfassung des Canary-Run-Berichts anzusehen.

## API-Canary
<a name="CloudWatch_Synthetics_Canaries_Blueprints_API"></a>

Über API Canarys können die grundlegenden Lese- und Schreibfunktionen einer REST-API getestet werden. REST steht für *Representational State Transfer* und ist eine Reihe von Regeln, die Entwickler bei der Erstellung einer API befolgen. Eine dieser Regeln besagt, dass ein Link zu einer bestimmten URL einen Datenabschnitt zurückgeben soll.

Canaries kann mit allen Funktionen arbeiten APIs und alle Arten von Funktionen testen. Jeder Canary kann mehrere API-Aufrufe ausführen.

Auf den Kanarischen Inseln, die eine Runtime-Version `syn-nodejs-2.2` oder eine neuere Version verwenden, unterstützt der API Canary Blueprint mehrstufige Canaries, die Ihre Schritte als HTTP überwachen. APIs Sie können mehrere auf einem einzigen Canary APIs testen. Jeder Schritt ist eine separate Anforderung, die auf eine andere URL zugreifen kann, unterschiedliche Header verwenden und unterschiedliche Regeln dafür verwenden kann, ob Kopfzeilen und Antwortkörper erfasst werden. Indem Sie Kopfzeilen und Antworttext nicht erfassen, können Sie verhindern, dass sensible Daten aufgezeichnet werden. 

Jede Anforderung in einem API-Canary besteht aus folgenden Informationen:
+ aus dem *Endpoint (Endpunkt)*, d. h. die URL, die Sie anfordern.
+ aus der *method (Methode)*, d. h. die Art der Anforderung, die an den Server gesendet wird. REST APIs unterstützt die Operationen GET (Lesen), POST (Schreiben), PUT (Update), PATCH (Update) und DELETE (Löschen).
+ aus den *headers (Headern)*, die Informationen sowohl für den Client als auch für den Server bereitstellen. Sie werden zur Authentifizierung und Bereitstellung von Informationen über den Body-Inhalt verwendet. Eine Liste der gültigen Header finden Sie unter [HTTP-Headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers).
+ Die *data (Daten)* (oder der *Body*), die Informationen enthalten, die an den Server gesendet werden sollen. Diese werden nur für POST-, PUT-, PATCH- oder DELETE-Anforderungen verwendet.

**Anmerkung**  
API-Canary-Vorlagen werden von Playwright-Laufzeiten nicht unterstützt.

Die API-Canary-Vorlage unterstützt GET- und POST-Methoden. Wenn Sie diese Vorlage verwenden, müssen Sie Header angeben. Sie können beispielsweise einen **Schlüssel** angeben **Authorization** und die erforderlichen Autorisierungsdaten als **Wert** für diesen Schlüssel angeben.

Wenn Sie eine POST-Anforderung testen, geben Sie auch den Inhalt, der veröffentlicht werden soll, im **Datenfeld** an.

 **Integration mit API Gateway** 

Der API-Blueprint ist in Amazon API Gateway integriert. Auf diese Weise können Sie eine API Gateway-API und Staging aus demselben AWS Konto und derselben Region wie der Canary auswählen oder eine Swagger-Vorlage für die konto- und regionsübergreifende API-Überwachung von API Gateway hochladen. Sie können dann die restlichen Details in der Konsole auswählen, um den Canary zu erstellen, anstatt sie von Grund auf neu einzugeben. Weitere Informationen zum API Gateway finden Sie unter [Was ist Amazon API Gateway?](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html). 

 **Verwenden einer privaten API** 

Sie können in Amazon API Gateway einen Canary erstellen, der eine private API verwendet. Weitere Informationen finden Sie unter [Private API in Amazon API Gateway erstellen](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html).

## Broken Link Checker
<a name="CloudWatch_Synthetics_Canaries_Blueprints_Broken_Links"></a>

Der Broken Link Checker sammelt alle Links innerhalb der URL, die Sie mit `document.getElementsByTagName('a')` testen. Er testet nur bis zu der von Ihnen angegebenen Anzahl von Links, wobei die URL selbst als erster Link gezählt wird. Wenn Sie beispielsweise alle Links auf einer Seite überprüfen möchten, die fünf Links enthält, müssen Sie angeben, dass das Canary sechs Links verfolgen soll.

Canarys für Broken Link Checker, die mit der `syn-nodejs-2.0-beta`-Laufzeit oder höher erstellt wurden, unterstützen die folgenden zusätzlichen Features:
+ Stellt einen Bericht bereit, der die überprüften Links, Statuscode, Fehlergrund (falls vorhanden) sowie Screenshots der Quell- und Zielseite enthält.
+ Wenn Sie Canary-Ergebnisse anzeigen, können Sie filtern, um nur die fehlerhaften Links anzuzeigen, und dann den Link basierend auf dem Grund des Fehlers beheben.
+ Diese Version erfasst für jeden Link kommentierte Quellseiten-Screenshots und hebt den Anker hervor, in dem der Link gefunden wurde. Ausgeblendete Komponenten werden nicht mit Anmerkungen versehen.
+ Sie können diese Version so konfigurieren, dass Screenshots von Quell- und Zielseiten, nur Quellseiten oder nur Zielseiten erfasst werden.
+ Diese Version behebt ein Problem in der früheren Version, bei dem das Canary-Skript nach dem ersten gebrochenen Link stoppt, selbst wenn mehr Links von der ersten Seite gescrapt werden.

**Anmerkung**  
Vorlagen zur Überprüfung defekter Links werden von Playwright-Laufzeiten nicht unterstützt.

Wenn Sie einen vorhandenen Canary mit `syn-1.0` aktualisieren möchten, um die neue Laufzeit zu verwenden, müssen Sie den Canary löschen und neu erstellen. Durch das Aktualisieren eines vorhandenen Canarys auf die neue Laufzeitumgebung werden diese Features nicht verfügbar gemacht.

Ein Broken Link Checker Canary (Canary für fehlerhafte Links) erkennt die folgenden Arten von Verbindungsfehlern:
+ 404 Seite nicht gefunden
+ Ungültiger Hostname
+ Falsche URL. In der URL fehlt z. B. eine Klammer, sie weist zusätzliche Schrägstriche auf oder es wird das falsche Protokoll verwendet.
+ Ungültiger HTTP-Antwortcode
+ Der Hostserver gibt leere Antworten ohne Inhalt und ohne Antwortcode zurück.
+ Die HTTP-Anforderungen weisen während der Canary-Ausführung ständig Zeitüberschreitungen auf.
+ Der Host bricht immer wieder Verbindungen ab, weil er falsch konfiguriert oder überlastet ist.

## Blueprint für die visuelle Überwachung
<a name="CloudWatch_Synthetics_Canaries_Blueprints_VisualTesting"></a>

Der visuelle Überwachungs-Blueprint enthält Code, um Screenshots, die während eines Canary-Laufs aufgenommen wurden, mit Screenshots zu vergleichen, die während eines Baseline-Canary-Laufs aufgenommen wurden. Wenn die Diskrepanz zwischen den beiden Screenshots einen Schwellenwert überschreitet, schlägt der Canary fehl. Die visuelle Überwachung wird auf Canaries unterstützt, auf denen **syn-puppeteer-node-3.2** und höher ausgeführt wird. Es wird derzeit nicht in Canarys unterstützt, die Python und Selenium ausführen oder Playwright-Laufzeiten nutzen.

Der Blueprint für die visuelle Überwachung enthält die folgende Codezeile im Canary-Standardskript für Blueprints, die die visuelle Überwachung ermöglicht.

```
syntheticsConfiguration.withVisualCompareWithBaseRun(true);
```

Wenn der Canary zum ersten Mal erfolgreich ausgeführt wird, nachdem diese Zeile zum Skript hinzugefügt wurde, verwendet er die während dieser Ausführung erstellten Screenshots als Vergleichsbasis. Nach dem ersten Canary-Run kannst du die CloudWatch Konsole verwenden, um den Canary zu bearbeiten, um einen der folgenden Schritte auszuführen:
+ Legen Sie den nächsten Lauf des Canarys als neue Basislinie fest.
+ Zeichnen Sie Grenzen auf dem aktuellen Baseline-Screenshot, um Bereiche des Screenshots festzulegen, die bei visuellen Vergleichen ignoriert werden sollen.
+ Entfernen Sie einen Screenshot, der für die visuelle Überwachung verwendet wird.

Weitere Informationen zur Verwendung der CloudWatch Konsole zum Bearbeiten eines Canary finden Sie unter[Einen Canary bearbeiten oder löschen](synthetics_canaries_deletion.md).

Sie können den Canary-Run, der als Baseline verwendet wird, auch ändern, indem Sie die `lastrun` Parameter ` nextrun` oder verwenden oder eine Canary-Run-ID in der [UpdateCanary](https://docs.aws.amazon.com/AmazonSynthetics/latest/APIReference/API_UpdateCanary.html)API angeben.

Wenn Sie den Blueprint für die visuelle Überwachung verwenden, geben Sie die URL ein, unter der der Screenshot erstellt werden soll, und geben einen Differenzschwellenwert als Prozentsatz an. Nach dem Baseline-Lauf lösen zukünftige Läufe des Canary, die einen visuellen Unterschied größer als dieser Schwellenwert erkennen, einen Canary-Fehler aus. Nach dem Baseline-Lauf können Sie den Canary auch bearbeiten, um Grenzen auf dem Baseline-Screenshot zu „zeichnen“, die Sie während der visuellen Überwachung ignorieren möchten.

Die visuelle Überwachungsfunktion basiert auf dem ImageMagick Open-Source-Software-Toolkit. Weitere Informationen finden Sie unter [ ImageMagick](https://imagemagick.org/index.php).

## Canary-Recorder
<a name="CloudWatch_Synthetics_Canaries_Blueprints_Recorder"></a>

Mit dem Canary Recorder-Blueprint können Sie den CloudWatch Synthetics Recorder verwenden, um Ihre Klick- und Tippaktionen auf einer Website aufzuzeichnen und automatisch ein Node.js -Skript zu generieren, mit dem Sie einen Canary erstellen können, der dieselben Schritte ausführt. Der CloudWatch Synthetics Recorder ist eine von Amazon bereitgestellte Google Chrome-Erweiterung. Der Canary Recorder wird für Canarys, die die Playwright-Laufzeit verwenden, nicht unterstützt.

**Credits**: Der CloudWatch Synthetics Recorder basiert auf dem [Headless](https://github.com/checkly/headless-recorder) Recorder.

Weitere Informationen finden Sie unter [Verwenden des CloudWatch Synthetics Recorders für Google Chrome](CloudWatch_Synthetics_Canaries_Recorder.md).

## GUI Workflow Builder
<a name="CloudWatch_Synthetics_Canaries_Blueprints_GUI_Workflow"></a>

Mit der GUI-Workflow-Builder-Vorlage wird überprüft, ob Aktionen auf Ihrer Webseite ausgeführt werden können. Wenn Sie zum Beispiel eine Webseite mit einem Anmeldeformular haben, kann das Canary die Benutzer- und Passwortfelder ausfüllen und das Formular abschicken, um zu überprüfen, ob die Webseite ordnungsgemäß funktioniert.

Wenn Sie eine Vorlage verwenden, um diesen Typ von Canary zu erstellen, geben Sie die Aktionen an, die das Canary auf der Webseite ausführen soll. Folgende Aktionen können Sie verwenden:
+ **Click** (Klicken) – Wählt das von Ihnen angegebene Element aus und simuliert einen Benutzer, der auf das Element klickt oder es auswählt.

  Um das Element in einem Skript „Node.js“ anzugeben, verwenden Sie `[id=]` oder ` a[class=]`.

  Um das Element in einem Python-Skript anzugeben, verwenden Sie `xpath //*[@id=]` oder ` //*[@class=]`.
+ **Verify selector (Auswahl überprüfen)** – Überprüft, ob das angegebene Element auf der Webseite vorhanden ist. Dieser Test ist nützlich, um zu überprüfen, ob eine vorherige Aktion dazu geführt hat, dass die Seite mit den richtigen Elementen ausgefüllt wird.

  Um das zu verifizierende Element in einem Skript „Node.js“ anzugeben, verwenden Sie `[id=]` oder ` a[class=]`.

  Um das zu überprüfende Element in einem Python-Skript anzugeben, verwenden Sie `xpath //*[@id=]` oder `//*[class=]`.
+ **Verify text** (Text überprüfen) – Überprüft, ob die angegebene Zeichenfolge im Zielelement enthalten ist. Dieser Test ist nützlich, um zu überprüfen, ob eine vorherige Aktion dazu geführt hat, dass der richtige Text angezeigt wird.

  Um das Element in einem Node.js-Skript anzugeben, verwenden Sie ein Format wie ` div[@id=]//h1`, da diese Aktion die `waitForXPath`-Funktion in Puppeteer verwendet.

  Um das Element in einem Python-Skript anzugeben, verwenden Sie das xpath-Format wie ` //*[@id=] ` oder //\$1[@class=], da diese Aktion die `implicitly_wait`-Funktion in Selenium verwendet.
+ **Input text** (Eingabetext) – Schreibt den angegebenen Text in das Zielelement.

  Um das zu verifizierende Element in einem Skript „Node.js“ anzugeben, verwenden Sie `[id=]` oder ` a[class=]`.

  Um das zu überprüfende Element in einem Python-Skript anzugeben, verwenden Sie `xpath //*[@id=]` oder `//*[@class=]`.
+ **Click with navigation** (Klicken bei Navigation) – Wartet auf das Laden der gesamten Seite, nachdem das angegebene Element ausgewählt wurde. Dies ist besonders nützlich, wenn Sie die Seite neu laden müssen.

  Um das Element in einem Skript „Node.js“ anzugeben, verwenden Sie `[id=]` oder ` a[class=]`.

  Um das Element in einem Python-Skript anzugeben, verwenden Sie `xpath //*[@id=]` oder ` //*[@class=]`.

Der folgende Blueprint verwendet beispielsweise Node.js. Es wird auf zuerst auf **firstButton** in der angegebenen URL geklickt und überprüft, ob die erwartete Auswahl mit dem erwarteten Text angezeigt wird, der Name `Test_Customer` wird in das Feld **Name** eingegeben, es wird auf die Schaltfläche **Login (Anmelden)** geklickt und dann überprüft, ob die Anmeldung erfolgreich ist, indem auf der nächsten Seite nach dem Text **Welcome** gesucht wird.

![\[Die Seite „Canary erstellen“ in der Konsole, mit ausgefüllten Feldern für die GUI Workflow-Vorlage.\]](http://docs.aws.amazon.com/de_de/AmazonCloudWatch/latest/monitoring/images/canary_create_gui_workflow.PNG)


GUI-Workflow-Canaries, die die folgenden Laufzeiten verwenden, bieten auch eine Zusammenfassung der Schritte, die für jeden Canary-Lauf ausgeführt werden. Sie können die Screenshots und die Fehlermeldung, die jedem Schritt zugeordnet sind, verwenden, um die Ursache des Fehlers zu finden.
+ `syn-nodejs-2.0` oder höher
+ `syn-python-selenium-1.0` oder höher

## Blueprint für mehrere Prüfungen
<a name="CloudWatch_Synthetics_Canaries_Blueprints_Multichecks_Blueprint"></a>

Der Multi-Check-Blueprint vereinfacht die Erstellung von Canaries. Er reduziert die Kosten durch die Verwendung einer einfachen JSON-Konfiguration, die out-of-the-box Funktionen für die Durchführung von HTTP-, DNS-, SSL- und TCP-Prüfungen bietet. Sie können bis zu 10 Prüfungen konfigurieren. Konfigurieren Sie jede Prüfung als numerischen Schritt, der sequentiell ausgeführt wird, um ein klares Verständnis des Kanarienflusses zu ermöglichen.

Blueprint-Unterstützung für Mehrfachprüfungen:
+ Grundlegende HTTP-Anfragen, TCP-Anfragen, Validierung von DNS-Datensätzen und Überwachung von SSL-Zertifikaten
+ In Secrets Manager integrierte HTTP-Authentifizierungsmethoden wie Basic OAuth, API Key und Sigv4
+ Assertionen für jede Prüfung

Weitere Informationen finden Sie unter [Erstellen eines Canarys](CloudWatch_Synthetics_Canaries_Create.md).

# Blueprint Canary für mehrere Checks erstellen
<a name="CloudWatch_Synthetics_Canaries_MultiCheck_Blueprint"></a>

Der Amazon CloudWatch Synthetics Multi Checks Blueprint hilft Ihnen dabei, einen Synthetics-Canary zu erstellen, indem es eine einfache JSON-Konfiguration bereitstellt. Sie können Kosten sparen, indem Sie bis zu 10 verschiedene Arten von HTTP/DNS/SSL/TCP Prüfungen schrittweise nacheinander bündeln. Jede Prüfung enthält Behauptungen, die eine grundlegende Überprüfung anhand eines Prüfergebnisses ermöglichen.

Multi Checks Canaries sind für einfache Anwendungsfälle konzipiert, die nur grundlegende Prüfungen ohne einen Headless-Browser erfordern. Für komplexere Anwendungsfälle schauen Sie sich die anderen Canary-Typen an, die Amazon CloudWatch Synthetics anbietet.

**Topics**
+ [Voraussetzungen](#CloudWatch_Synthetics_MultiCheck_Prerequisites)
+ [Einschränkungen](#CloudWatch_Synthetics_MultiCheck_Limitations)
+ [Verpackungsstruktur, JSON-Schema und Konfigurationseinstellungen](#CloudWatch_Synthetics_MultiCheck_Packaging)
+ [Einen Multi-Check-Canary in erstellen AWS-Managementkonsole](#CloudWatch_Synthetics_MultiCheck_Console)
+ [Mit AWS Synthetics einen Multi-Check-Kanarienvogel erstellen APIs](#CloudWatch_Synthetics_MultiCheck_API)
+ [Einen Canary-in mit mehreren Check-Ins erstellen CloudFormation](#CloudWatch_Synthetics_MultiCheck_CloudFormation)
+ [Authentifizierungs-Konfiguration](#CloudWatch_Synthetics_MultiCheck_Authentication)
+ [Fehlerbehebung](#CloudWatch_Synthetics_MultiCheck_Troubleshooting)

## Voraussetzungen
<a name="CloudWatch_Synthetics_MultiCheck_Prerequisites"></a>
+ Muss syn-nodejs-3.0\$1 verwenden, um einen Multi-Check-Canary zu erstellen
+ Wenn Sie die Authentication and Secrets Manager Manager-Konfiguration verwenden, müssen Sie sicherstellen, dass der Canary [ ExecutionRoleArn](https://docs.aws.amazon.com/AmazonSynthetics/latest/APIReference/API_CreateCanary.html)die Berechtigungen für den Zugriff auf diese Geheimnisse gewährt
+ Wenn Sie die Authentifizierung für Sigv4 verwenden, müssen Sie sicherstellen, dass der Canary [ ExecutionRoleArn](https://docs.aws.amazon.com/AmazonSynthetics/latest/APIReference/API_CreateCanary.html)die Berechtigungen für den Zugriff auf die entsprechende Rolle gewährt

## Einschränkungen
<a name="CloudWatch_Synthetics_MultiCheck_Limitations"></a>
+ Die Größe der HTTP-Antwort darf nicht größer als 1 MB sein
+ Maximal 10 definierte Variablen.
+ Bei Verwendung des JSON-RFC kann das Checks JSON doppelte Felder enthalten, sofern jedoch nur das letzte sequentielle Feld verwendet wird
+ In einem Canary mit mehreren Prüfungen werden standardmäßig Metriken mit mehreren Prüfschritten angezeigt, um die Verfügbarkeit der einzelnen Checks leicht zu ermitteln. AWS-Managementkonsole Wenn Schecks entfernt werden, zeigt dieses Diagramm die Checks möglicherweise immer noch im Verfügbarkeitsdiagramm an, bis die Metrik für mindestens 3 Stunden nicht mehr aktiv ist

## Verpackungsstruktur, JSON-Schema und Konfigurationseinstellungen
<a name="CloudWatch_Synthetics_MultiCheck_Packaging"></a>

Die JSON-Checks-Konfiguration, die für den Canary verwendet wird, muss benannt ` blueprint-config.json` werden. Die Konfiguration muss dem [Schema](https://github.com/aws-samples/synthetics-canary-local-debugging-sample/tree/main) und den Anweisungen unter folgen[Schreiben einer JSON-Konfiguration für den Blueprint Node.js Multi Checks](CloudWatch_Synthetics_WritingCanary_Multichecks.md).

Komprimieren Sie die Datei `blueprint-config.json` in eine ZIP-Datei und stellen Sie sie in einem der folgenden Erstellungs-Workflows bereit. Wenn es eine `synthetics.json` Konfiguration gibt, wird sie auch in derselben ZIP-Datei komprimiert. Im Folgenden finden Sie ein Beispiel für eine Zip-Datei mit dem Namen`multi-checks.zip`.

```
multi-checks.zip
├── blueprint-config.json
└── synthetics.json
```

## Einen Multi-Check-Canary in erstellen AWS-Managementkonsole
<a name="CloudWatch_Synthetics_MultiCheck_Console"></a>

1. Öffnen Sie die Amazon CloudWatch Synthetics-Konsole.

1. Wählen Sie **Canary erstellen** aus.

1. Wählen **Sie unter Blueprint verwenden** die Option **Multi** Checks aus.

   Unter **Checks konfigurieren** findest du zwei Tabs: **Checks** und **Canary-Konfiguration**.

1. Wählen Sie die Runtime-Version **syn-nodejs-3.0** oder höher aus.

1. Gehen Sie wie unten beschrieben vor, um die Prüfung [Schreiben einer JSON-Konfiguration für den Blueprint Node.js Multi Checks](CloudWatch_Synthetics_WritingCanary_Multichecks.md) zu beschreiben, die Sie durchführen möchten. Alternativ bietet Ihnen die Konsole eine Standard-JSON-Konfiguration, auf der Sie aufbauen können.

1. Wählen Sie **Canary erstellen** aus.

## Mit AWS Synthetics einen Multi-Check-Kanarienvogel erstellen APIs
<a name="CloudWatch_Synthetics_MultiCheck_API"></a>

Verwenden Sie die `CreateCanary` API und geben Sie innerhalb des `Code` Parameters das field/value `BlueprintTypes="multi-checks"` anstelle von an. ` Handler` Wenn `BlueprintTypes` sowohl als auch angegeben `Handler` sind, `ValidationException` wird a angezeigt. Die bereitgestellte Runtime-Version muss `syn-nodejs-3.0` oder höher sein.

```
aws synthetics create-canary \
    --name my-multi-check-canary \
    --code ZipFile="ZIP_BLOB",BlueprintTypes="multi-checks" \
    --runtime-version syn-nodejs-3.0 \
    ...

// Or if you wanted to use S3 to provide your code.

aws synthetics create-canary \
    --name my-multi-check-canary \
    --code S3Bucket="my-code-bucket",S3Key="my-zip-code-key",BlueprintTypes="multi-checks" \
    ...
```

## Einen Canary-in mit mehreren Check-Ins erstellen CloudFormation
<a name="CloudWatch_Synthetics_MultiCheck_CloudFormation"></a>

Geben Sie in Ihrer CloudFormation Vorlage für einen Canary mit mehreren Checks innerhalb des `Code` Parameters das field/value `BlueprintTypes="multi-checks"` anstelle von an. ` Handler` Wenn `BlueprintTypes` sowohl als auch angegeben `Handler` sind, `ValidationException` wird a angezeigt. Die bereitgestellte Runtime-Version muss sein`syn-nodejs-3.0 or later`. 

Eine Beispielvorlage:

```
SyntheticsCanary:
    Type: 'AWS::Synthetics::Canary'
    Properties:
      Name: MyCanary
      RuntimeVersion: syn-nodejs-3.0
      Schedule: {Expression: 'rate(5 minutes)', DurationInSeconds: 3600}
      ...
      Code:
        S3Bucket: "my-code-bucket"
        S3Key: "my-zip-code-key"
        BlueprintTypes: ["multi-checks"]
      ...
```

## Authentifizierungs-Konfiguration
<a name="CloudWatch_Synthetics_MultiCheck_Authentication"></a>

Wenn dein Canary HTTP-Anfragen an einen authentifizierten Endpunkt sendet, kannst du die Schritte deines Blueprint Canary so konfigurieren, dass er einen von vier Authentifizierungstypen verwendet: Basic, API Key, OAuth Client Credentials und SigV4. Anstatt selbst Anforderungsheader einzurichten, können Sie in Ihrer Blueprint-Definition einen Authentifizierungstyp angeben, und Synthetics folgt dem angegebenen Authentifizierungstyp, um die Komponenten Ihrer HTTP-Anfrage mit den bereitgestellten Authentifizierungsinformationen zu füllen.

Sie geben in Ihrem Blueprint-Schritt im Abschnitt Authentifizierung einen Authentifizierungstyp an. Sie geben das Authentifizierungsschema an, das Sie verwenden möchten, die Eigenschaften, die für das von Ihnen gewählte Authentifizierungsschema erforderlich sind, und Synthetics verwendet die bereitgestellten Informationen, um einen Authentifizierungsheader für Ihre HTTP-Anfrage zu erstellen.

Da das Speichern von Geheimnissen (wie Passwörtern oder API-Schlüsseln) im Klartext ein Sicherheitsproblem darstellt, unterstützt Synthetics die Integration mit AWS Secrets Manager. Wenn Sie eine HTTP-Anfrage in einem Synthetics-Blueprint-Canary authentifizieren möchten, können Sie auf das Secret verweisen, in dem Ihre Authentifizierungsinformationen gespeichert sind, und Synthetics kümmert sich darum, das Geheimnis abzurufen und in Ihrem Canary zwischenzuspeichern. Dieser Ansatz stellt Synthetics Geheimnisse zur Verfügung und bewahrt Ihre Geheimnisse gleichzeitig sicher auf, ohne sie in Ihrer Blueprint-Konfiguration im Klartext anzugeben.

Weitere Informationen zu finden Sie AWS Secrets Manager unter [Was ist? AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)

### Grundlegende Authentifizierung
<a name="CloudWatch_Synthetics_MultiCheck_BasicAuth"></a>

Synthetics implementiert das in RFC 7617 definierte grundlegende HTTP-Authentifizierungsschema. Das Verfahren funktioniert folgendermaßen:
+ Ein Paar aus Benutzername und Passwort wird aus der Blueprint-Konfiguration bereitgestellt.
+ Der Benutzerpass wird durch die Verkettung des Benutzernamens, eines einzelnen Doppelpunkts („:“) und des Kennworts erstellt.
+ Der Benutzerpass ist UTF-8-kodiert und wird dann in eine Base64-kodierte Zeichenfolge umgewandelt.
+ Dieser Base64-kodierte Benutzerpass wird im Header „Authorization“ mit dem folgenden Format bereitgestellt: Authorization: Basic \$1base64-\$1 encoded-user-pass

Wenn der Benutzeragent beispielsweise die Benutzer-ID „Aladdin“ und das Passwort „open sesame“ senden möchte, verwendet er das folgende Header-Feld: Authorization: Basic ftZQ== QWxh ZGRpbjpvc GVu IHNlc2

Beispielkonfiguration:

```
"Authentication": {
    "type": "BASIC",
    "username": MY_USERNAME, // Required
    "password": MY_PASSWORD // Required
}
```

### API-Schlüsselauthentifizierung
<a name="CloudWatch_Synthetics_MultiCheck_APIKeyAuth"></a>

Sie können einen API-Schlüssel zur Authentifizierung Ihrer HTTP-Anfragen angeben. Wenn Sie die API-Schlüsselauthentifizierung verwenden, wird Ihr bereitgestellter API-Schlüssel in den HTTP-Header „X-API-Key“ eingefügt. Wenn Sie eine benutzerdefinierte Ressource haben, die in einem anderen Header nach API-Schlüssel-Headern sucht, können Sie optional einen anderen Header-Namen angeben, in den Synthetics den API-Schlüssel einfügen soll.

Beispielkonfiguration:

```
"Authentication": {
    "type": "API_KEY",
    "apiKey": S0A1M2P3L4E5, // Required
    "header": X-Specific-Header // Optional, defaults to "X-API-Key"
}
```

### SigV4-Authentifizierung
<a name="CloudWatch_Synthetics_MultiCheck_SigV4Auth"></a>

AWS Sigv4 (Signature Version 4) ist das AWS Signaturprotokoll zum Hinzufügen von Authentifizierungsinformationen zu API-Anfragen. AWS Um eine SIGV4-authentifizierte Anfrage zu stellen, müssen Sie die Region und den Dienst angeben, an den Sie Anfragen stellen, sowie einen ARN (AWS Ressourcenname) angeben, der eine IAM-Rolle identifiziert, die der Canary bei dieser SigV4-Anfrage übernehmen soll. Synthetics übernimmt die im roleArn bereitgestellte IAM-Rolle und verwendet sie, um Ihre API-Anfrage zu authentifizieren. AWS 

Beispielkonfiguration:

```
"Authentication": {
    "type": "SIGV4",
    "region": us-west-2, // Required
    "service": s3, // Required
    "roleArn": arn:AWS:iam:12345678912:role/SampleRole // Required
}
```

#### Überlegungen zu SigV4
<a name="CloudWatch_Synthetics_MultiCheck_SigV4Considerations"></a>

Damit Synthetics die Rolle übernimmt, die Sie im Abschnitt zur SigV4-Authentifizierung angegeben haben, muss die dieser Rolle zugeordnete Vertrauensrichtlinie so konfiguriert sein, dass der Canary das bereitgestellte roleArn übernehmen kann. Der AWS Principal, dem Sie vertrauen müssen, ist die Rolle, die Ihr Canary übernommen hat. AWS STS Es hat das Format ` aws:sts::{account_running_the_canary}:assumed-role/<canary_name>/<assumed_role_name>` arn:.

Wenn beispielsweise ein Canary unter dem Konto 0123456789012 mit dem Namen test-canary läuft und die Rolle, die er angenommen hat, benannt wurde, muss die Vertrauensrichtlinie diese Anweisung enthalten canary-assume-role, damit der Canary die Rolearn-Authentifizierung für SigV4-Authentifizierung korrekt übernimmt:

```
{
    "Effect": "Allow",
    "Principal": {
        "AWS": "arn:AWS:sts::123456789012:assumed-role/test-canary/"
    },
    "Action": "sts:AssumeRole"
}
```

### OAuth Kundenanmeldedaten
<a name="CloudWatch_Synthetics_MultiCheck_OAuthAuth"></a>

Synthetics implementiert den Grant-Typ OAuth Client Credentials, wie in RFC 6479 Abschnitt 4.4 definiert. Wenn Sie eine HTTP-Anfrage an einen Endpunkt stellen möchten, der mit einem von einem Token-Endpunkt ausgegebenen Bearer-Token authentifiziert wurde, kann Synthetics in Ihrem Namen ein Bearer-Token anfordern und verwalten. OAuth Wenn Sie das OAuth Schema verwenden, führt Synthetics die folgenden Schritte aus:
+ Verwendet das Standardauthentifizierungsschema mit clientId und ClientSecret, um eine Anfrage an die TokenUrl zu authentifizieren, den Endpunkt, der Inhabertoken ausgibt
+ Wenn Sie die optionalen Parameter Scope, Audience und Resource angeben, sind diese in der Token-Anfrage enthalten
+ Verwendet das von der TokenUrl zurückgegebene Zugriffstoken, um Ihre HTTP-Anfrage zu authentifizieren
+ Speichert das von der TokenURL zurückgegebene Aktualisierungstoken sicher für future Token-Anfragen

Beispielkonfiguration:

```
"Authentication": {
    "type": "OAUTH_CLIENT_CREDENTIALS",
    "tokenUrl": ..., // Required
    "clientId": ..., // Required
    "clientSecret": ..., // Required
    "scope": ..., // Optional
    "audience": ..., // Optional
    "resource": ..., // Optional
}
```

#### OAuth Überlegungen
<a name="CloudWatch_Synthetics_MultiCheck_OAuthConsiderations"></a>

Synthetics aktualisiert OAuth Token, wenn eine 401- oder 407-Antwort zurückgegeben wird.

### AWS Secrets Manager Integration
<a name="CloudWatch_Synthetics_MultiCheck_SecretsManager"></a>

Um zu vermeiden, dass geheime Werte (wie Passwörter oder API-Schlüssel) im Klartext gespeichert werden, bietet Synthetics eine Integration mit AWS Secrets Manager. Sie können mit dem Format ` ${aws_SECRET:<secret_name>}` auf einen gesamten geheimen Wert in Ihrer Blueprint-Konfiguration verweisen oder auf einen bestimmten Schlüssel verweisen. ` ${aws_SECRET:<secret_name>:<secret_key>}`

Wenn Sie beispielsweise ein Geheimnis namens login/ habenbasic-auth-credentials, das einen Benutzernamen und ein Passwort mit der folgenden JSON-Struktur speichert:

```
{
    "username": "Aladdin",
    "password": "open sesame"
}
```

Sie können den Benutzernamen und das Passwort in Ihrer Blueprint-Konfiguration wie folgt referenzieren, und Synthetics kümmert sich um das Abrufen des geheimen Werts und die Verwendung seiner Schlüssel zur Authentifizierung Ihrer Anfrage:

```
"Authentication": {
    "type": "BASIC",
    "username": ${AWS_SECRET:login/basic-auth-credentials:username},
    "password": ${AWS_SECRET:login/basic-auth-credentials:password}
}
```

Damit Synthetics das angegebene Geheimnis abrufen kann, muss die vom Canary übernommene Rolle ARN über SecretsManager: -Berechtigungen verfügen. GetSecretValue Wenn das Geheimnis mit einem vom Kunden verwalteten Schlüssel anstelle des verwalteten Schlüssels AWS/secretsmanager verschlüsselt AWS wird, benötigen Sie auch Decrypt-Berechtigungen für diesen Schlüssel. kms:

Beispielberechtigungen:

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "secretsmanager:GetSecretValue",
            "Resource": "arn:AWS:secretsmanager:us-east-1:123456789012:secret:secretName-AbCdEf"
        },
        {
            "Effect": "Allow",
            "Action": "kms:Decrypt",
            "Resource": "arn:AWS:kms:us-east-1:123456789012:key/key-id"
        }
    ]
}
```

## Fehlerbehebung
<a name="CloudWatch_Synthetics_MultiCheck_Troubleshooting"></a>

### Häufige Fehler bei der Fehlerbehebung
<a name="CloudWatch_Synthetics_MultiCheck_Common_Failures"></a>

Der zugrunde liegende Code für den Multi-Check-Blueprint ist in Typescript geschrieben. Auf der Seite zur Fehlerbehebung bei Canary finden Sie häufig auftretende Fehler: [Fehlerbehebung bei einem](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_Troubleshoot.html) ausgefallenen Canary.

### Syntaxfehler bei der JSON-Überprüfung der Konfiguration
<a name="CloudWatch_Synthetics_MultiCheck_JSON_Errors"></a>

Wenn es irgendwelche syntaktischen Fehler im Zusammenhang mit der JSON-Prüfkonfiguration des Canary gibt, AWS-Managementkonsole erhalten Sie eine Fehlerursache, wenn Sie versuchen, den Canary zu erstellen. Wenn du einen Canary mithilfe einer API oder erstellst CloudFormation, wirst du den Fehler sehen, wenn der Canary zum ersten Mal ausgeführt wird. Es wird empfohlen, den Workflow für sichere Canary-Updates für Multi Check Canary zu verwenden. Weitere Informationen findest du unter [Sichere Canary-Updates durchführen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/performing-safe-canary-upgrades.html).

### Netzwerk- oder Timeout-Fehler
<a name="CloudWatch_Synthetics_MultiCheck_Network_Failures"></a>

Bei sporadisch auftretenden oder andauernden Ausfällen im Zusammenhang mit Timeouts oder Netzwerkverbindungsfehlern (z. B. ENOTFOUND, ECONNRESET) sollten Sie in Erwägung ziehen, ` DEBUG` Protokolle zu aktivieren, sodass der folgende Rechenlauf weitere Informationen darüber liefert, warum die Prüfungen fehlschlagen. Geben Sie dazu die Umgebungsvariable CW\$1SYNTHETICS\$1LOG\$1LEVEL: „DEBUG“ an.

Wenn es immer noch Fehler gibt, die Sie nicht debuggen können, sollten Sie sich an den AWS Support wenden oder prüfen, ob einer der anderen von CloudWatch Synthetics bereitgestellten Canary-Typen besser zu Ihrem Anwendungsfall passt.