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. # Ein Canary-Skript schreiben In den folgenden Abschnitten wird erklärt, wie man ein Canary-Skript schreibt und wie man ein Canary-Skript in andere AWS Dienste und mit externen Abhängigkeiten und Bibliotheken integriert. **Topics** + [Schreiben eines Canary-Skript mit der Java-Laufzeit](Synthetics_WritingCanary_Java.md) + [Schreiben eines Node.js-Canary-Skript mit der Playwright-Laufzeit](Synthetics_WritingCanary_Nodejs_Playwright.md) + [Schreiben eines Node.js-Canary-Skript mit der Puppeteer-Laufzeit](CloudWatch_Synthetics_Canaries_WritingCanary_Nodejs_Pup.md) + [Ein Python-Canary-Skript schreiben](CloudWatch_Synthetics_Canaries_WritingCanary_Python.md) + [Schreiben einer JSON-Konfiguration für den Blueprint Node.js Multi Checks](CloudWatch_Synthetics_WritingCanary_Multichecks.md) # Schreiben eines Canary-Skript mit der Java-Laufzeit **Topics** + [Java-Projektstruktur für ein Canary](#Synthetics_canary_Java_package) + [Bündeln des Projekt für einen Canary](#Synthetics_canary_Java_package_canary) + [Handlername](#Synthetics_canary_Java_handler) + [CloudWatch Synthetics Konfigurationen](#Synthetics_canary_Java_config) + [CloudWatch Synthetics-Umgebungsvariablen](#Synthetics_canary_Java_variables) ## Java-Projektstruktur für ein Canary Zur Erstellung eines Canary in Java müssen Sie Ihren Code schreiben, kompilieren und die kompilierten Artefakte in Synthetics bereitstellen. Sie können ein Java-Lambda-Projekt auf verschiedene Arten initialisieren. Sie können beispielsweise ein Standard-Java-Projekt-Setup in Ihrer bevorzugten IDE wie IntelliJ IDEA oder Visual Studio Code verwenden. Alternativ können Sie die erforderliche Dateistruktur manuell erstellen. Ein Synthetics-Java-Projekt hat die folgende allgemeine Struktur: ``` /project-root └ src └ main └ java └ canarypackage // name of package | └ ExampleCanary.java // Canary code file | └ other_supporting_classes - resources └ synthetics.json // Synthetics configuration file └ build.gradle OR pom.xml ``` Sie können entweder Maven oder Gradle verwenden, um Ihr Projekt zu erstellen und Abhängigkeiten zu verwalten. In der obigen Struktur ist die `ExampleCanary`-Klasse der Einstiegspunkt oder Handler für den Canary. **Beispiel für eine Canary-Java-Klasse** In diesem Beispiel stellt ein Canary eine GET-Anfrage an eine URL, die in der Lambda-Umgebungsvariablen *TESTING\$1URL* gespeichert ist. Der Canary verwendet keine der von Synthetics-Laufzeit bereitgestellten Methoden. ``` package canarypackage; import java.net.HttpURLConnection; import java.net.URL; // Handler value: canary.ExampleCanary::canaryCode public class ExampleCanary { public void canaryCode() throws Exception{ URL url = new URL(System.getenv("TESTING_URL")); HttpURLConnection con=(HttpURLConnection)url.openConnection(); con.setRequestMethod("GET"); con.setConnectTimeout(5000); con.setReadTimeout(5000); int status=con.getResponseCode(); if(status!=200){ throw new Exception("Failed to load " + url + ", status code: " + status); } } } ``` Es wird dringend empfohlen, Ihre Canarys mithilfe der von Synthetics bereitgestellten Bibliotheksfunktion `executeStep` zu modularisieren. Der Canary `get` ruft zwei separate Variablen auf, die von und von der URLs Umgebung stammen. URL1 URL2 **Anmerkung** Zur Verwendung der `executeStep`-Funktionalität sollte die Handler-Methode für den Canary einen Parameter vom Typ Synthetics verwenden, wie unten gezeigt. ``` package canarypackage; import com.amazonaws.synthetics.Synthetics; import java.net.HttpURLConnection; import java.net.URL; // Handler value: canary.ExampleCanary::canaryCode public class ExampleCanary { public void canaryCode(Synthetics synthetics) throws Exception { createStep("Step1", synthetics, System.getenv("URL1")); createStep("Step2", synthetics, System.getenv("URL2")); return; } private void createStep(String stepName, Synthetics synthetics, String url) throws Exception{ synthetics.executeStep(stepName,()->{ URL obj=new URL(url); HttpURLConnection con=(HttpURLConnection)obj.openConnection(); con.setRequestMethod("GET"); con.setConnectTimeout(5000); con.setReadTimeout(5000); int status=con.getResponseCode(); if(status!=200){ throw new Exception("Failed to load" + url + "status code:" + status); } return null; }).get(); } } ``` ## Bündeln des Projekt für einen Canary Synthetics akzeptiert Code für einen Java-Canary im *Zip*-Format. Die ZIP-Datei besteht aus den Klassendateien für den Canary-Code, den Jars für alle Abhängigkeiten von Drittanbietern und der Synthetics-Konfigurationsdatei. Ein Synthetics-Java-Zip enthält die folgende allgemeine Struktur. ``` example-canary └ lib | └ //third party dependency jars └ java-canary.jar └ synthetics.json ``` Um diese Zip-Datei aus der obigen Projektstruktur zu erstellen, können Sie Gradle (build.gradle) oder Maven (pom.xml) verwenden. Ein Beispiel. [Informationen zu Abhängigkeiten oder Schnittstellen zur Kompilierzeit für die Synthetics-Bibliothek finden Sie in der README-Datei unter aws-cloudwatch-synthetics-sdk -java.](https://github.com/aws/aws-cloudwatch-synthetics-sdk-java/tree/main) ``` plugins { id 'java' } repositories { mavenCentral() } dependencies { // Third party dependencies // example: implementation 'software.amazon.awssdk:s3:2.31.9' // Declares dependency on Synthetics interfaces for compiling only // Refer https://github.com/aws/aws-cloudwatch-synthetics-sdk-java for building from source. compileOnly 'software.amazon.synthetics:aws-cloudwatch-synthetics-sdk-java:1.0.0'} test { useJUnitPlatform() } // Build the zip to be used as Canary code. task buildZip(type: Zip) { archiveFileName.set("example-canary.zip") destinationDirectory.set(file("$buildDir")) from processResources into('lib') { from configurations.runtimeClasspath from(tasks.named("jar")) } from "src/main/java/resources/synthetics.json" doLast { println "Artifact written to: ${archiveFile.get().asFile.absolutePath}" } } java { toolchain { languageVersion = JavaLanguageVersion.of(21) } } tasks.named("build") { dependsOn "buildZip" } ``` ## Handlername Der Handler-Name ist der Einstiegspunkt für den Canary. Für die Java-Laufzeit hat der Handler das folgende Format. ``` <>::<> // for above code: canarypackage.ExampleCanary::canaryCode ``` ## CloudWatch Synthetics Konfigurationen Sie können das Verhalten der Synthetics-Java-Laufzeit konfigurieren, indem Sie eine optionale JSON-Konfigurationsdatei mit dem Namen `synthetics.json` bereitstellen. Diese Datei sollte im Stammverzeichnis der Paket-Zip-Datei gebündelt werden. Eine Konfigurationsdatei ist zwar optional, CloudWatch verwendet aber die Standardwerte, wenn Sie keine Konfigurationsdatei angeben oder ein Konfigurationsschlüssel fehlt. Im Folgenden sind die unterstützten Konfigurationswerte und ihre Standardwerte aufgeführt. ``` { "step": { "stepSuccessMetric": true, "stepDurationMetric": true, "continueOnStepFailure": false, "stepsReport": true }, "logging": { "logRequest": false, "logResponse": false }, "httpMetrics": { "metric_2xx": true, "metric_4xx": true, "metric_5xx": true, "aggregated2xxMetric": true, "aggregated4xxMetric": true, "aggregated5xxMetric": true }, "canaryMetrics": { "failedCanaryMetric": true, "aggregatedFailedCanaryMetric": true } } ``` **Schritt-Konfigurationen** + *continueOnStepFehler* — Legt fest, ob ein Skript auch dann fortgesetzt werden soll, wenn ein Schritt fehlgeschlagen ist. Der Standardwert lautet „false“. + *stepSuccessMetric* – Ermittelt, ob die ` SuccessPercent`-Metrik eines Schritts ausgegeben wird. Die `SuccessPercent` Metrik für einen Schritt ist *100* für den Canary-Run, wenn der Schritt erfolgreich ist, und *0*, wenn der Schritt fehlschlägt. Der Standardwert ist *true*. + *stepDurationMetric*— Bestimmt, ob die Metrik „*Dauer*“ eines Schritts ausgegeben wird. Die *Dauer*-Metrik wird als Dauer der Ausführung des Schritts in Millisekunden ausgegeben. Die Standardeinstellung ist „*true“*. **Protokollierungskonfigurationen** Gilt für von CloudWatch Synthetics generierte Protokolle. Steuert die Ausführlichkeit von Anforderungs- und Antwortprotokollen. + *logRequest* – Gibt an, ob jede Anforderung in Canary-Protokollen protokolliert werden soll. Der Standardwert lautet „false“. + *logResponse* – Gibt an, ob jede Antwort in Canary-Protokollen protokolliert werden soll. Der Standardwert lautet „false“. **Konfigurationen der HTTP-Metrik** Konfigurationen für Metriken, die sich auf die Anzahl der Netzwerkanfragen mit unterschiedlichen HTTP-Statuscodes beziehen, die von CloudWatch Synthetics für diesen Kanarienvogel ausgegeben wurden. + *metric\$12xx* — Gibt an, ob die 2xx-Metrik (mit der *Dimension) für diesen* Canary ausgegeben werden soll. CanaryName Der Standardwert ist *true*. + *metric\$14xx — Gibt an, ob die 4xx-Metrik* (mit der Dimension) für diesen Canary *ausgegeben* werden soll. CanaryName Der Standardwert ist *true*. + *metric\$15xx — Gibt an, ob die 5xx-Metrik* (mit der Dimension) für diesen Canary *ausgegeben* werden soll. CanaryName Der Standardwert ist *true*. + *Aggregated2xxMetric — Gibt an, ob die 2xx-Metrik* (ohne die Dimension) für diesen Canary *ausgegeben* werden soll. CanaryName Der Standardwert ist *true*. + *Aggregated4xxMetric — Gibt an, ob die 4xx-Metrik* (ohne die Dimension) für diesen Canary *ausgegeben* werden soll. CanaryName Der Standardwert ist *true*. + *Aggregated5xxMetric — Gibt an, ob die 5xx-Metrik* (ohne die Dimension) für diesen Canary *ausgegeben* werden soll. CanaryName Der Standardwert ist *true*. **Konfigurationen der Canary-Metrik** Konfigurationen für andere von CloudWatch Synthetics ausgegebene Metriken. + *failedCanaryMetric*Network Access Analyzer Gibt an, ob die Metrik *Fehlgeschlagen* (mit der CanaryName Dimension) für diesen Canary ausgegeben werden soll. Der Standardwert ist *true*. + *aggregatedFailedCanaryMetrik* — Gibt an, ob die Metrik „*Fehlgeschlagen*“ (ohne die CanaryName Dimension) für diesen Canary ausgegeben werden soll. Der Standardwert ist *true*. ## CloudWatch Synthetics-Umgebungsvariablen Sie können die Protokollierungsebene und das Format mithilfe von Umgebungsvariablen konfigurieren. **Protokollformat** Die CloudWatch Synthetics Java Runtime erstellt CloudWatch Logs für jeden Canary-Run. Die Protokolle werden zur einfacheren Abfrage im JSON-Format geschrieben. Optional können Sie das Protokollformat zu *TEXT* ändern. + *Name der Umgebungsvariable* – CW\$1SYNTHETICS\$1LOG\$1FORMAT + *Unterstützte Werte* – JSON, TEXT + *Standard* – JSON **Protokollstufen** + *Name der Umgebungsvariable* – CW\$1SYNTHETICS\$1LOG\$1LEVEL + *Unterstützte Werte* – TRACE, DEBUG, INFO, WARN, ERROR, FATAL + *Standard* – INFO Abgesehen von den oben genannten Umgebungsvariablen wurde eine Standardumgebungsvariable für die Java-Laufzeit hinzugefügt, eine `AWS_LAMBDA-EXEC_WRAPPER`-Umgebungsvariable zu Ihrer Funktion, und deren Wert auf `/opt/synthetics-otel-instrument` festgelegt. Diese Umgebungsvariable ändert das Startverhalten Ihrer Funktion für Telemetrie. Wenn diese Umgebungsvariable bereits existiert, stellen Sie sicher, dass sie auf den erforderlichen Wert festgelegt ist. # Schreiben eines Node.js-Canary-Skript mit der Playwright-Laufzeit **Topics** + [Bündeln Ihrer Node.js-Canary-Dateien für die Playwright-Laufzeit](#Synthetics_canary_Nodejs_Playwright_package) + [Änderung eines vorhandenen Playwright-Skripts zur Verwendung als CloudWatch Synthetics Canary](#CloudWatch_Synthetics_canary_edit_Playwright_script) + [CloudWatch Synthetics Konfigurationen](#Synthetics_canary_configure_Playwright_script) ## Bündeln Ihrer Node.js-Canary-Dateien für die Playwright-Laufzeit Ihr Canary-Skript besteht aus einer `.js` (CommonJS-Syntax) oder `.mjs` (ES-Syntax)-Datei, die Ihren Synthetics-Handler-Code enthält, zusammen mit allen zusätzlichen Paketen und Modulen, von denen Ihr Code abhängt. Im ES (ECMAScript) -Format erstellte Skripts sollten entweder .mjs als Erweiterung verwenden oder eine package.json-Datei mit dem Feldsatz „type“: „module“ enthalten. Im Gegensatz zu anderen Laufzeiten wie Node.js Puppeteer müssen Sie Ihre Skripts nicht in einer bestimmten Ordnerstruktur speichern. Sie können Ihre Skripte direkt bündeln. Erstellen Sie mit Ihrem bevorzugten `zip`-Programm eine `.zip`-Datei mit Ihrer Handler-Datei im Stammverzeichnis. Wenn Ihr Canary-Skript von zusätzlichen Paketen oder Modulen abhängt, die nicht in der Synthetics-Laufzeit enthalten sind, können Sie diese Abhängigkeiten zu Ihrer `.zip`-Datei hinzufügen. Um dies zu tun, können Sie die erforderlichen Bibliotheken Ihrer Funktion im `node_modules`-Verzeichnis installieren, indem Sie den `npm install`-Befehl ausführen. Die folgenden CLI-Befehle erstellen eine `.zip`-Datei mit dem Namen `my_deployment_package.zip`, welche die `index.js`- oder `index.mjs`-Datei (Synthetics-Handler) und die zugehörigen Abhängigkeiten enthält. Im Beispiel installieren Sie Abhängigkeiten mit dem `npm`-Paketmanager. ``` ~/my_function ├── index.mjs ├── synthetics.json ├── myhelper-util.mjs └── node_modules ├── mydependency ``` Erstellen Sie im Stammverzeichnis eine `.zip`-Datei mit den Inhalten Ihres Projektordners. Verwenden Sie die `r` (rekursive) Option, wie im folgenden Beispiel gezeigt, um sicherzustellen, dass `zip` die Unterordner komprimiert. ``` zip -r my_deployment_package.zip . ``` Fügen Sie eine Synthetics-Konfigurationsdatei hinzu, um das Verhalten von CloudWatch Synthetics zu konfigurieren. Sie können eine `synthetics.json`-Datei erstellen und sie unter demselben Pfad wie Ihren Einstiegspunkt oder Ihre Handler-Datei speichern. Optional können Sie Ihre Einstiegspunktdatei auch in einer Ordnerstruktur Ihrer Wahl speichern. Stellen Sie jedoch sicher, dass der Ordnerpfad in Ihrem Handlernamen angegeben ist. **Handlername** Legen Sie den Skript-Eintrittspunkt Ihres Canary (Handler) als ` myCanaryFilename.functionName` fest, damit er mit dem Dateinamen des Skript-Eintrittspunkts übereinstimmt. Sie können den Canary auch in einem separaten Ordner (z. B. ` myFolder/my_canary_filename.mjs`) ablegen. Wenn Sie ihn in einem separaten Ordner speichern, geben Sie den entsprechenden Pfad in Ihrem Skript-Eintrittspunkt an (z. B. ` myFolder/my_canary_filename.functionName`). ## Änderung eines vorhandenen Playwright-Skripts zur Verwendung als CloudWatch Synthetics Canary Sie können ein vorhandenes Skript für Node.js und Playwright bearbeiten, um es als Canary zu verwenden. Weitere Informationen zu Playwright finden Sie in der Dokumentation in der [Playwright-Bibliothek](https://playwright.dev/docs/api/class-playwright). Sie können das folgende Playwright-Skript verwenden, das in der Datei ` exampleCanary.mjs` gespeichert ist. ``` import { chromium } from 'playwright'; import { expect } from '@playwright/test'; const browser = await chromium.launch(); const page = await browser.newPage(); await page.goto('https://example.com', {timeout: 30000}); await page.screenshot({path: 'example-home.png'}); const title = await page.title(); expect(title).toEqual("Example Domain"); await browser.close(); ``` Konvertieren Sie das Skript wie folgt: 1. Erstellen und exportieren Sie eine `handler`-Funktion. Der Handler ist die Eintrittsfunktion für das Skript. Sie können einen beliebigen Namen für die Handler-Funktion wählen, aber die Funktion, die in Ihrem Skript verwendet wird, sollte dieselbe sein wie in Ihrem Canary-Handler. Wenn Ihr Skriptname `exampleCanary.mjs` lautet und der Name der Handler-Funktion `myhandler` lautet, wird Ihr Canary-Handler `exampleCanary.myhandler` genannt. Im folgenden Beispiel lautet der Name der Handler-Funktion `handler`. ``` exports.handler = async () => { // Your script here }; ``` 1. Importieren Sie das `Synthetics Playwright module` als Abhängigkeit. ``` import { synthetics } from '@aws/synthetics-playwright'; ``` 1. Starten Sie einen Browser mit der Synthetics `Launch`-Funktion. ``` const browser = await synthetics.launch(); ``` 1. Erstellen Sie mithilfe der Synthetics `newPage`-Funktion eine neue Playwright-Seite. ``` const page = await synthetics.newPage(); ``` Ihr Skript kann nun als Synthetics-Canary ausgeführt werden. Das aktualisierte Skript ist das folgende: **Das Format des Skripts wurde aktualisiert ES6 ** Die Skriptdatei wurde mit einer `.mjs`-Erweiterung gespeichert. ``` import { synthetics } from '@aws/synthetics-playwright'; import { expect } from '@playwright/test'; export const handler = async (event, context) => { try { // Launch a browser const browser = await synthetics.launch(); // Create a new page const page = await synthetics.newPage(browser); // Navigate to a website await page.goto('https://www.example.com', {timeout: 30000}); // Take screenshot await page.screenshot({ path: '/tmp/example.png' }); // Verify the page title const title = await page.title(); expect(title).toEqual("Example Domain"); } finally { // Ensure browser is closed await synthetics.close(); } }; ``` **Aktualisiertes Skript im CommonJS-Format** Die Skriptdatei wurde mit einer `.js`-Erweiterung gespeichert. ``` const { synthetics } = require('@aws/synthetics-playwright'); const { expect } = require('@playwright/test'); exports.handler = async (event) => { try { const browser = await synthetics.launch(); const page = await synthetics.newPage(browser); await page.goto('https://www.example.com', {timeout: 30000}); await page.screenshot({ path: '/tmp/example.png' }); const title = await page.title(); expect(title).toEqual("Example Domain"); } finally { await synthetics.close(); } }; ``` ## CloudWatch Synthetics Konfigurationen Sie können das Verhalten der Synthetics-Playwright-Laufzeit konfigurieren, indem Sie eine optionale JSON-Konfigurationsdatei mit dem Namen `synthetics.json` bereitstellen. Diese Datei sollte am selben Speicherort wie die Handler-Datei gebündelt werden. Eine Konfigurationsdatei ist zwar optional, wenn Sie jedoch keine Konfigurationsdatei angeben oder ein Konfigurationsschlüssel fehlt, wird von Standardwerten CloudWatch ausgegangen. **Bündeln Ihrer Konfigurationsdatei** Im Folgenden sind die unterstützten Konfigurationswerte und ihre Standardwerte aufgeführt. ``` { "step": { "screenshotOnStepStart": false, "screenshotOnStepSuccess": false, "screenshotOnStepFailure": false, "stepSuccessMetric": true, "stepDurationMetric": true, "continueOnStepFailure": true, "stepsReport": true }, "report": { "includeRequestHeaders": true, "includeResponseHeaders": true, "includeUrlPassword": false, "includeRequestBody": true, "includeResponseBody": true, "restrictedHeaders": ['x-amz-security-token', 'Authorization'], // Value of these headers is redacted from logs and reports "restrictedUrlParameters": ['Session', 'SigninToken'] // Values of these url parameters are redacted from logs and reports }, "logging": { "logRequest": false, "logResponse": false, "logResponseBody": false, "logRequestBody": false, "logRequestHeaders": false, "logResponseHeaders": false }, "httpMetrics": { "metric_2xx": true, "metric_4xx": true, "metric_5xx": true, "failedRequestsMetric": true, "aggregatedFailedRequestsMetric": true, "aggregated2xxMetric": true, "aggregated4xxMetric": true, "aggregated5xxMetric": true }, "canaryMetrics": { "failedCanaryMetric": true, "aggregatedFailedCanaryMetric": true }, "userAgent": "", "har": true } ``` **Schritt-Konfigurationen** + `screenshotOnStepStart` – Legt fest, ob Synthetics vor Beginn des Schritts einen Screenshot aufnehmen soll. Der Standardwert ist `true`. + `screenshotOnStepSuccess` – Legt fest, ob Synthetics einen Screenshot aufnehmen soll, nachdem ein Schritt erfolgreich war. Der Standardwert ist `true`. + `screenshotOnStepFailure` – Legt fest, ob Synthetics einen Screenshot aufnehmen soll, nachdem ein Schritt fehlgeschlagen ist. Der Standardwert ist `true`. + `continueOnStepFailure` – Legt fest, ob ein Skript auch dann fortgesetzt werden soll, wenn ein Schritt fehlgeschlagen ist. Der Standardwert ist `false`. + `stepSuccessMetric` – Bestimmt, ob die ` SuccessPercent`-Metrik eines Schritts ausgegeben wird. Die `SuccessPercent`-Metrik für einen Schritt ist `100` für die Canary-Ausführung, wenn der Schritt erfolgreich ist und `0`, wenn der Schritt fehlschlägt. Der Standardwert ist `true`. + `stepDurationMetric` – Ermittelt, ob die `Duration`-Metrik eines Schritts ausgegeben wird. Die `Duration`-Metrik wird als Dauer der Ausführung des Schritts in Millisekunden ausgegeben. Der Standardwert ist `true`. **Konfigurationen melden** Beinhaltet alle von CloudWatch Synthetics generierten Berichte, z. B. eine HAR-Datei und einen Synthetics-Schrittbericht. Felder zur Schwärzung sensibler Daten `restrictedHeaders` und `restrictedUrlParameters` gelten auch für von Synthetics generierte Protokolle. + `includeRequestHeaders` – Gibt an, ob Anforderungs-Header in den Bericht aufgenommen werden sollen. Der Standardwert ist `false`. + `includeResponseHeaders` – Gibt an, ob Antwort-Header in den Bericht aufgenommen werden sollen. Der Standardwert ist `false`. + `includeUrlPassword` – Gibt an, ob ein Passwort eingefügt werden soll, das in der URL angezeigt wird. Standardmäßig URLs werden Passwörter, die in erscheinen, aus Protokollen und Berichten entfernt, um die Offenlegung vertraulicher Daten zu verhindern. Der Standardwert ist `false`. + `includeRequestBody` – Gibt an, ob der Anforderungstext in den Bericht aufgenommen werden soll. Der Standardwert ist `false`. + `includeResponseBody` – Gibt an, ob der Antworttext in den Bericht aufgenommen werden soll. Der Standardwert ist `false`. + `restrictedHeaders` – Eine Liste von Header-Werten, die ignoriert werden sollen, wenn Header enthalten sind. Dies gilt sowohl für Anforderungs- als auch für Antwort-Header. Sie können Ihre Anmeldeinformationen beispielsweise verbergen, indem Sie `includeRequestHeaders` als wahr und `restrictedHeaders` als `['Authorization']` übergeben. + `restrictedUrlParameters` – Eine Liste von URL-Pfad- oder Abfrageparametern, die geschwärzt werden sollen. Dies gilt für Daten URLs , die in Protokollen, Berichten und Fehlern vorkommen. Bei dem Parameter wird die Groß-/Kleinschreibung nicht beachtet. Sie können ein Sternchen (`*`) als Wert übergeben, um alle URL-Pfad- und Abfrageparameterwerte zu überarbeiten. Der Standardwert ist ein leeres Array. + `har` – Legt fest, ob ein HTTP-Archiv (HAR) generiert werden soll. Der Standardwert ist `true`. Nachfolgend finden Sie ein Beispiel einer Berichts-Konfigurationsdatei. ``` "includeRequestHeaders": true, "includeResponseHeaders": true, "includeUrlPassword": false, "includeRequestBody": true, "includeResponseBody": true, "restrictedHeaders": ['x-amz-security-token', 'Authorization'], // Value of these headers is redacted from logs and reports "restrictedUrlParameters": ['Session', 'SigninToken'] // Values of these URL parameters are redacted from logs and reports ``` **Protokollierungskonfigurationen** Gilt für von CloudWatch Synthetics generierte Protokolle. Steuert die Ausführlichkeit von Anforderungs- und Antwortprotokollen. + `logRequest` – Gibt an, ob jede Anforderung in Canary-Protokollen protokolliert werden soll. Bei UI-Canarys protokolliert dies jede Anforderung, die vom Browser gesendet wird. Der Standardwert ist ` false`. + `logResponse` – Gibt an, ob jede Antwort in Canary-Protokollen protokolliert werden soll. Bei UI-Canarys protokolliert dies jede vom Browser empfangene Antwort. Der Standardwert ist ` false`. + `logRequestBody` – Gibt an, ob Anforderungstexte zusammen mit den Anforderungen in Canary- Protokollen protokolliert werden sollen. Diese Konfiguration gilt nur, wenn `logRequest` wahr ist. Der Standardwert ist `false`. + `logResponseBody` – Gibt an, ob Anforderungstexte zusammen mit den Anforderungen in Canary-Protokollen protokolliert werden sollen. Diese Konfiguration gilt nur, wenn `logResponse` wahr ist. Der Standardwert ist `false`. + `logRequestHeaders` – Gibt an, ob Anforderungsheader zusammen mit den Anforderungen in Canary-Protokollen protokolliert werden sollen. Diese Konfiguration gilt nur, wenn ` logRequest` wahr ist. Der Standardwert ist `false`. + `logResponseHeaders` – Gibt an, ob Antwortheader zusammen mit den Antworten in Canary-Protokollen protokolliert werden sollen. Diese Konfiguration gilt nur, wenn ` logResponse` wahr ist. Der Standardwert ist `false`. **Konfigurationen von HTTP-Metriken** Konfigurationen für Metriken, die sich auf die Anzahl der Netzwerkanfragen mit unterschiedlichen HTTP-Statuscodes beziehen, die von CloudWatch Synthetics für diesen Kanarienvogel ausgegeben wurden. + `metric_2xx` – Gibt an, ob die `2xx`-Metrik (mit der `CanaryName`-Dimension) für diesen Canary emittiert werden soll. Der Standardwert ist ` true`. + `metric_4xx` – Gibt an, ob die `4xx`-Metrik (mit der `CanaryName`-Dimension) für diesen Canary emittiert werden soll. Der Standardwert ist ` true`. + `metric_5xx` – Gibt an, ob die `5xx`-Metrik (mit der `CanaryName`-Dimension) für diesen Canary emittiert werden soll. Der Standardwert ist ` true`. + `failedRequestsMetric` – Gibt an, ob die ` failedRequests`-Metrik (mit der `CanaryName`-Dimension) für diesen Canary emittiert werden soll. Der Standardwert ist `true`. + `aggregatedFailedRequestsMetric` – Gibt an, ob die ` failedRequests`-Metrik (ohne die `CanaryName`-Dimension) für diesen Canary emittiert werden soll. Der Standardwert ist `true`. + `aggregated2xxMetric` – Gibt an, ob die `2xx`-Metrik (ohne die `CanaryName`-Dimension) für diesen Canary emittiert werden soll. Der Standardwert ist `true`. + `aggregated4xxMetric` – Gibt an, ob die `4xx`-Metrik (ohne die `CanaryName`-Dimension) für diesen Canary emittiert werden soll. Der Standardwert ist `true`. + `aggregated5xxMetric` – Gibt an, ob die `5xx`-Metrik (ohne die `CanaryName`-Dimension) für diesen Canary emittiert werden soll. Der Standardwert ist `true`. **Canary-Metrik-Konfigurationen** Konfigurationen für andere von CloudWatch Synthetics ausgegebene Metriken. + `failedCanaryMetric` – Gibt an, ob die `Failed`-Metrik (mit der `CanaryName`-Dimension) für diesen Canary emittiert werden soll. Der Standardwert ist ` true`. + `aggregatedFailedCanaryMetric` – Gibt an, ob die ` Failed`-Metrik (ohne die `CanaryName`-Dimension) für diesen Canary emittiert werden soll. Der Standardwert ist `true`. **Sonstige Konfigurationen** + `userAgent` – Eine Zeichenfolge, die an den Benutzeragenten angehängt werden soll. Der Benutzeragent ist eine Zeichenfolge, die im Anforderungsheader enthalten ist und Ihren Browser gegenüber Websites identifiziert, die Sie besuchen, wenn Sie den Headless-Browser verwenden. CloudWatch Synthetics fügt automatisch hinzu`CloudWatchSynthetics/canary-arn to the user agent`. Die angegebene Konfiguration wird an den generierten Benutzeragenten angehängt. Der Standard-Benutzeragent, der angehängt wird, ist eine leere Zeichenfolge (`""`). ### CloudWatch Synthetics-Umgebungsvariablen Konfigurieren Sie die Protokollierungsebene und das Format mithilfe von Umgebungsvariablen. **Protokollformat** Die CloudWatch Synthetics Playwright Runtime erstellt CloudWatch Protokolle für jeden Canary-Run. Die Protokolle werden zur bequemen Abfrage im JSON-Format geschrieben. Optional können Sie das Protokollformat in `TEXT` ändern. + `Environment variable name` – CW\$1SYNTHETICS\$1LOG\$1FORMAT + `Supported values` – JSON, TEXT + `Default` – JSON **Protokollstufen** Die Aktivierung des Modus `Debug` erhöht zwar die Ausführlichkeit, kann aber bei der Fehlerbehebung nützlich sein. + `Environment variable name` – CW\$1SYNTHETICS\$1LOG\$1LEVEL + `Supported values` – TRACE, DEBUG, INFO, WARN, ERROR, FATAL + `Default` – INFO # Schreiben eines Node.js-Canary-Skript mit der Puppeteer-Laufzeit **Topics** + [Einen CloudWatch Synthetics-Kanarienvogel von Grund auf neu erstellen](#CloudWatch_Synthetics_Canaries_write_from_scratch) + [Bündeln Ihrer Node.js-Canary-Dateien](#CloudWatch_Synthetics_Canaries_package) + [Ändern eines vorhandenen Puppeteer-Skripts zur Verwendung als Synthetics-Canary](#CloudWatch_Synthetics_Canaries_modify_puppeteer_script) + [Umgebungsvariablen](#CloudWatch_Synthetics_Environment_Variables) + [Integriere deinen Canary mit anderen AWS Diensten](#CloudWatch_Synthetics_Canaries_AWS_integrate) + [Verwenden Sie Ihren Canary dazu, eine statische IP-Adresse zu verwenden](#CloudWatch_Synthetics_Canaries_staticIP) ## Einen CloudWatch Synthetics-Kanarienvogel von Grund auf neu erstellen Hier ist ein Beispiel für die Minimalversion eines Canary-Skripts für Synthetics. Dieses Skript wird als erfolgreiche Ausführung übergeben und gibt eine Zeichenfolge zurück. Um zu sehen, wie ein fehlerhaftes Canary aussieht, ändern Sie `let fail = false;` zu `let fail = true;`. Sie müssen eine Eintrittspunkt-Funktion für das Canary-Skript definieren. Um zu sehen, wie Dateien in den Amazon-S3-Speicherort hochgeladen werden, der als `ArtifactS3Location` des Canary angegeben ist, erstellen Sie diese Dateien unter dem Ordner `/tmp`. Alle Canary-Artefakte sollten in `/tmp` gespeichert werden, da es das einzige beschreibbare Verzeichnis ist. Vergewissern Sie sich, dass der Screenshot-Pfad auf `/tmp` für alle Screenshots oder andere Dateien, die mit dem Skript erstellt wurden, festgelegt ist. Synthetics lädt Dateien in ` /tmp` automatisch in einen S3-Bucket hoch. ``` /tmp/ ``` Nach der Ausführung des Skripts werden der pass/fail Status und die Dauer in einem S3-Bucket veröffentlicht CloudWatch und die darunter liegenden Dateien `/tmp` werden in einen S3-Bucket hochgeladen. ``` const basicCustomEntryPoint = async function () { // Insert your code here // Perform multi-step pass/fail check // Log decisions made and results to /tmp // Be sure to wait for all your code paths to complete // before returning control back to Synthetics. // In that way, your canary will not finish and report success // before your code has finished executing // Throw to fail, return to succeed let fail = false; if (fail) { throw "Failed basicCanary check."; } return "Successfully completed basicCanary checks."; }; exports.handler = async () => { return await basicCustomEntryPoint(); }; ``` Als Nächstes erweitern wir das Skript, um die Synthetics-Protokollierung zu verwenden und mithilfe des AWS SDK einen Anruf zu tätigen. Zu Demonstrationszwecken erstellt dieses Skript einen Amazon-DynamoDB-Client und ruft die DynamoDB-listTables-API auf. Es protokolliert die Antwort auf die Anforderung und protokolliert entweder „pass“ (erfolgreich) oder „fail“ (nicht erfolgreich), je nachdem, ob die Anforderung erfolgreich war. ``` const log = require('@aws/synthetics-logger'); const AWS = require('aws-sdk'); // Require any dependencies that your script needs // Bundle additional files and dependencies into a .zip file with folder structure // nodejs/node_modules/additional files and folders const basicCustomEntryPoint = async function () { log.info("Starting DynamoDB:listTables canary."); let dynamodb = new AWS.DynamoDB(); var params = {}; let request = await dynamodb.listTables(params); try { let response = await request.promise(); log.info("listTables response: " + JSON.stringify(response)); } catch (err) { log.error("listTables error: " + JSON.stringify(err), err.stack); throw err; } return "Successfully completed DynamoDB:listTables canary."; }; exports.handler = async () => { return await basicCustomEntryPoint(); }; ``` ## Bündeln Ihrer Node.js-Canary-Dateien **Für syn-nodejs-puppeteer -11.0 und höher** Die ältere Verpackungsstruktur (für syn-nodejs-puppeteer -10.0 und niedriger) wird in neueren Versionen immer noch unterstützt. Erstellen Sie ein Skript mit einer der folgenden Optionen: + .js-Datei (CommonJS-Syntax) + .mjs-Datei (Syntax der ES-Module) Verwenden Sie für ES-Module eine der folgenden Optionen: + .js-Datei (CommonJS-Syntax) + .mjs-Datei (Syntax der ES-Module) Die Paketstruktur ist unten definiert: + Handler-Datei auf Stammebene (index.js/index.mjs) + Optionale Konfigurationsdatei (synthetics.json) + Zusätzliche Abhängigkeiten in node\$1modules (falls erforderlich) Beispiel für eine Paketstruktur: ``` my_function/ ├── index.mjs ├── synthetics.json ├── helper-utils.mjs └── node_modules/ └── dependencies ``` Führen Sie zum Bündeln die folgenden Schritte aus: 1. Installieren Sie Abhängigkeiten (falls vorhanden). ``` npm install ``` 1. Erstellen Sie ein .zip-Paket. ``` zip -r my_deployment_package.zip ``` **Für syn-nodejs-puppeteer -11.0 und niedriger** Für die Nutzung von Amazon S3 ist die folgende Struktur erforderlich: ``` nodejs/ └── node_modules/ └── myCanaryFilename.js ``` **Um in -3.4\$1 eine optionale Unterstützung für Unterordner hinzuzufügen: syn-nodejs-puppeteer** ``` nodejs/ └── node_modules/ └── myFolder/ └── myCanaryFilename.js ``` **Anmerkung** Der Handler-Pfad in der Konfiguration muss mit dem Dateispeicherort übereinstimmen. **Handlername** Legen Sie den Skript-Eintrittspunkt Ihres Canary (Handler) als ` myCanaryFilename.functionName` fest, damit er mit dem Dateinamen des Skript-Eintrittspunkts übereinstimmt. Wenn Sie eine Laufzeit vor `syn-nodejs-puppeteer-3.4` verwenden, muss `functionName` `handler` sein. Wenn Sie ` syn-nodejs-puppeteer-3.4` oder neuer verwenden, können Sie einen beliebigen Funktionsnamen als Handler auswählen. Wenn Sie `syn-nodejs-puppeteer-3.4` oder neuer verwenden, können Sie den Canary auch in einem separaten Ordner (z. B. ` nodejs/node_modules/myFolder/my_canary_filename`) ablegen. Wenn Sie ihn in einem separaten Ordner speichern, geben Sie den entsprechenden Pfad in Ihrem Skript-Eintrittspunkt an (z. B. ` myFolder/my_canary_filename.functionName`). ## Ändern eines vorhandenen Puppeteer-Skripts zur Verwendung als Synthetics-Canary In diesem Abschnitt wird erläutert, wie Puppeteer-Skripte so geändert werden, dass sie als Synthetics-Canary-Skripte ausgeführt werden können. Weitere Informationen zu Puppeteer finden Sie unter [Puppeteer API v1.14.0](https://github.com/puppeteer/puppeteer/blob/v1.14.0/docs/api.md). Wir beginnen mit diesem Puppeteer-Beispielskript: ``` const puppeteer = require('puppeteer'); (async () => { const browser = await puppeteer.launch(); const page = await browser.newPage(); await page.goto('https://example.com'); await page.screenshot({path: 'example.png'}); await browser.close(); })(); ``` Für die Konvertierung sind die folgenden Schritte durchzuführen: + Erstellen und exportieren Sie eine `handler`-Funktion. Der Handler ist die Eintrittsfunktion für das Skript. Wenn Sie eine Laufzeit vor ` syn-nodejs-puppeteer-3.4` verwenden, muss die Handler-Funktion den Namen `handler` haben. Wenn Sie `syn-nodejs-puppeteer-3.4` oder neuer verwenden, kann die Funktion einen beliebigen Namen haben. Dieser Name muss jedoch mit dem Namen im Skript übereinstimmen. Wenn Sie `syn-nodejs-puppeteer-3.4` oder neuer verwenden, können Sie Ihre Skripte außerdem in einem beliebigen Ordner ablegen und diesen Ordner als Teil des Handlernamens angeben. ``` const basicPuppeteerExample = async function () {}; exports.handler = async () => { return await basicPuppeteerExample(); }; ``` + Verwenden Sie die `Synthetics`-Abhängigkeit. ``` var synthetics = require('@aws/synthetics-puppeteer'); ``` + Verwenden Sie die `Synthetics.getPage`-Funktion, um ein Puppeteer-`Page`-Objekt zu erhalten. ``` const page = await synthetics.getPage(); ``` **Das von der Synthetics.GetPage-Funktion zurückgegebene Seitenobjekt hat den Wert page.on und Ereignisse, die für die Protokollierung instrumentiert sind.** `request` `response` ` requestfailed` Synthetics richtet auch die Generierung von HAR-Dateien für Anforderungen und Antworten auf der Seite ein und fügt den Benutzeragenten-Headern der ausgehenden Anforderungen auf der Seite den Canary-ARN hinzu. Das Skript kann nun als Synthetics-Canary ausgeführt werden. Nachfolgend finden Sie das aktualisierte Skript: ``` var synthetics = require('@aws/synthetics-puppeteer'); // Synthetics dependency const basicPuppeteerExample = async function () { const page = await synthetics.getPage(); // Get instrumented page from Synthetics await page.goto('https://example.com'); await page.screenshot({path: '/tmp/example.png'}); // Write screenshot to /tmp folder }; exports.handler = async () => { // Exported handler function return await basicPuppeteerExample(); }; ``` ## Umgebungsvariablen Sie können Umgebungsvariablen beim Erstellen von Canaries verwenden. Auf diese Weise können Sie ein einzelnes Canaryskript schreiben und dann dieses Skript mit unterschiedlichen Werten verwenden, um schnell mehrere Canarys zu erstellen, die eine ähnliche Aufgabe haben. Angenommen, Ihre Organisation verfügt über Endpunkte wie `prod`, ` dev` und `pre-release` für die verschiedenen Phasen Ihrer Softwareentwicklung und Sie müssen Canaries erstellen, um jeden dieser Endpunkte zu testen. Sie können ein einzelnes Canary-Skript schreiben, das Ihre Software testet, und dann andere Werte für die Endpunkt-Umgebungsvariable angeben, wenn Sie die drei Canarys erstellen. Wenn Sie dann einen Canary erstellen, geben Sie das Skript und die Werte an, die für die Umgebungsvariablen verwendet werden sollen. Die Namen von Umgebungsvariablen können Buchstaben, Zahlen und den Unterstrich enthalten. Sie müssen mit einem Buchstaben beginnen und mindestens zwei Zeichen enthalten. Die Gesamtgröße Ihrer Umgebungsvariablen darf einen Wert von 4 KB nicht überschreiten. Sie können keine reservierten Lambda-Umgebungsvariablen als Namen Ihrer Umgebungsvariablen angeben. Weitere Informationen zu reservierten Umgebungsvariablen finden Sie unter [Laufzeitumgebungsvariablen](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-runtime). **Wichtig** Schlüssel und Werte von Umgebungsvariablen werden im Ruhezustand mit AWS eigenen AWS KMS Schlüsseln verschlüsselt. Die Umgebungsvariablen sind jedoch nicht clientseitig verschlüsselt. Speichern Sie keine sensiblen Daten darin. Das folgende Beispielskript verwendet zwei Umgebungsvariablen. Dieses Skript ist für einen Canary bestimmt, der prüft, ob eine Webseite verfügbar ist. Es verwendet Umgebungsvariablen, um sowohl die URL, die es überprüft, als auch die verwendete CloudWatch Synthetics-Protokollebene zu parametrisieren. Die folgende Funktion setzt `LogLevel` auf den Wert der Umgebungsvariablen ` LOG_LEVEL`. ``` synthetics.setLogLevel(process.env.LOG_LEVEL); ``` Diese Funktion setzt `URL` auf den Wert der Umgebungsvariablen `URL`. ``` const URL = process.env.URL; ``` Dies ist das komplette Skript. Wenn Sie mit diesem Skript einen Canary erstellen, geben Sie Werte für die Umgebungsvariablen `LOG_LEVEL` und `URL` an. ``` var synthetics = require('@aws/synthetics-puppeteer'); const log = require('@aws/synthetics-logger'); const pageLoadEnvironmentVariable = async function () { // Setting the log level (0-3) synthetics.setLogLevel(process.env.LOG_LEVEL); // INSERT URL here const URL = process.env.URL; let page = await synthetics.getPage(); //You can customize the wait condition here. For instance, //using 'networkidle2' may be less restrictive. const response = await page.goto(URL, {waitUntil: 'domcontentloaded', timeout: 30000}); if (!response) { throw "Failed to load page!"; } //Wait for page to render. //Increase or decrease wait time based on endpoint being monitored. await page.waitFor(15000); await synthetics.takeScreenshot('loaded', 'loaded'); let pageTitle = await page.title(); log.info('Page title: ' + pageTitle); log.debug('Environment variable:' + process.env.URL); //If the response status code is not a 2xx success code if (response.status() < 200 || response.status() > 299) { throw "Failed to load page!"; } }; exports.handler = async () => { return await pageLoadEnvironmentVariable(); }; ``` ### Übergeben von Umgebungsvariablen an Ihr Skript Um Umgebungsvariablen an Ihr Skript zu übergeben, wenn Sie einen Canary in der Konsole erstellen, geben Sie die Schlüssel und Werte der Umgebungsvariablen im Abschnitt **Umgebungsvariablen** der Konsole an. Weitere Informationen finden Sie unter [Erstellen eines Canarys](CloudWatch_Synthetics_Canaries_Create.md). Um Umgebungsvariablen über die API oder zu übergeben AWS CLI, verwenden Sie den ` EnvironmentVariables` Parameter im Abschnitt. `RunConfig` Im Folgenden finden Sie einen AWS CLI Beispielbefehl, der einen Canary erstellt, der zwei Umgebungsvariablen mit den Schlüsseln `Environment` und verwendet`Region`. ``` aws synthetics create-canary --cli-input-json '{ "Name":"nameofCanary", "ExecutionRoleArn":"roleArn", "ArtifactS3Location":"s3://amzn-s3-demo-bucket-123456789012-us-west-2", "Schedule":{ "Expression":"rate(0 minute)", "DurationInSeconds":604800 }, "Code":{ "S3Bucket": "canarycreation", "S3Key": "cwsyn-mycanaryheartbeat-12345678-d1bd-1234-abcd-123456789012-12345678-6a1f-47c3-b291-123456789012.zip", "Handler":"pageLoadBlueprint.handler" }, "RunConfig": { "TimeoutInSeconds":60, "EnvironmentVariables": { "Environment":"Production", "Region": "us-west-1" } }, "SuccessRetentionPeriodInDays":13, "FailureRetentionPeriodInDays":13, "RuntimeVersion":"syn-nodejs-2.0" }' ``` ## Integriere deinen Canary mit anderen AWS Diensten Alle Kanarienvögel können die AWS SDK-Bibliothek verwenden. Du kannst diese Bibliothek verwenden, wenn du deinen Canary schreibst, um den Canary in andere AWS Dienste zu integrieren. Dazu müssen Sie den folgenden Code zu Ihrem Canary hinzufügen. In diesen Beispielen AWS Secrets Manager wird sie als Dienst verwendet, in den der Canary integriert wird. + Importieren Sie das AWS SDK. ``` const AWS = require('aws-sdk'); ``` + Erstellen Sie einen Client für den AWS Service, in den Sie integrieren. ``` const secretsManager = new AWS.SecretsManager(); ``` + Verwenden Sie den Client, um API-Aufrufe für diesen Service durchzuführen. ``` var params = { SecretId: secretName }; return await secretsManager.getSecretValue(params).promise(); ``` Das folgende Code-Snippet aus einem Canary-Skript veranschaulicht anhand eines Beispiels die Integration in Secrets Manager detaillierter. ``` var synthetics = require('@aws/synthetics-puppeteer'); const log = require('@aws/synthetics-logger'); const AWS = require('aws-sdk'); const secretsManager = new AWS.SecretsManager(); const getSecrets = async (secretName) => { var params = { SecretId: secretName }; return await secretsManager.getSecretValue(params).promise(); } const secretsExample = async function () { let URL = ""; let page = await synthetics.getPage(); log.info(`Navigating to URL: ${URL}`); const response = await page.goto(URL, {waitUntil: 'domcontentloaded', timeout: 30000}); // Fetch secrets let secrets = await getSecrets("secretname") /** * Use secrets to login. * * Assuming secrets are stored in a JSON format like: * { * "username": "", * "password": "" * } **/ let secretsObj = JSON.parse(secrets.SecretString); await synthetics.executeStep('login', async function () { await page.type(">USERNAME-INPUT-SELECTOR<", secretsObj.username); await page.type(">PASSWORD-INPUT-SELECTOR<", secretsObj.password); await Promise.all([ page.waitForNavigation({ timeout: 30000 }), await page.click(">SUBMIT-BUTTON-SELECTOR<") ]); }); // Verify login was successful await synthetics.executeStep('verify', async function () { await page.waitForXPath(">SELECTOR<", { timeout: 30000 }); }); }; exports.handler = async () => { return await secretsExample(); }; ``` ## Verwenden Sie Ihren Canary dazu, eine statische IP-Adresse zu verwenden Sie können einen Canary so einrichten, dass er eine statische IP-Adresse verwendet. **So erzwingen Sie einen Canary dazu, eine statische IP-Adresse zu verwenden** 1. Erstellen einer neuen VPC. Weitere Informationen finden Sie unter [Using DNS with Your VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html). 1. Erstellen eines neuen Internet-Gateways Weitere Informationen finden Sie unter [Hinzufügen eines Internet-Gateways zu Ihrer VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html#working-with-igw). 1. Erstellen Sie ein öffentliches Subnetz in Ihrer neuen VPC. 1. Fügen Sie der VPC eine neue Routing-Tabelle hinzu. 1. Fügen Sie in der neuen Routing-Tabelle eine Route hinzu, die von `0.0.0.0/0` zum Internet-Gateway führt. 1. Verknüpfen Sie die neue Routing-Tabelle dem öffentlichen Subnetz. 1. Erstellen einer elastischen IP-Adresse Weitere Informationen finden Sie unter [elastische IP-Adressen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html). 1. Erstellen Sie ein neues NAT-Gateway und weisen Sie es dem öffentlichen Subnetz und der elastischen IP-Adresse zu. 1. Erstellen Sie ein privates Subnetz innerhalb der VPC. 1. Fügen Sie der VPC-Standard-Routing-Tabelle eine Route hinzu, die von `0.0.0.0/0` zum NAT-Gateway geht 1. Erstellen Sie Ihr Canary. # Ein Python-Canary-Skript schreiben Dieses Skript wird als erfolgreiche Ausführung übergeben und gibt eine Zeichenfolge zurück. Um zu sehen, wie ein fehlgeschlagener Canary aussieht, ändern Sie Fail = False in Fail = True ``` def basic_custom_script(): # Insert your code here # Perform multi-step pass/fail check # Log decisions made and results to /tmp # Be sure to wait for all your code paths to complete # before returning control back to Synthetics. # In that way, your canary will not finish and report success # before your code has finished executing fail = False if fail: raise Exception("Failed basicCanary check.") return "Successfully completed basicCanary checks." def handler(event, context): return basic_custom_script() ``` ## Bündeln Ihrer Python-Canary-Dateien Wenn Sie mehr als eine .py-Datei haben oder Ihr Skript eine Abhängigkeit aufweist, können Sie sie alle in einer einzigen ZIP-Datei bündeln. Wenn Sie die `syn-python-selenium-1.1`-Laufzeit verwenden, muss die ZIP-Datei Ihre canary.py-Datei in einem `python`-Ordner enthalten (z. B. `python/my_canary_filename.py`). Wenn Sie ` syn-python-selenium-1.1` oder neuer verwenden, können Sie auch einen anderen Ordner nutzen, etwa `python/myFolder/my_canary_filename.py`. Diese ZIP-Datei sollte alle erforderlichen Ordner und Dateien enthalten, die anderen Dateien müssen sich jedoch nicht im `python`-Ordner befinden. Legen Sie den Skript-Eintrittspunkt Ihres Canary als ` my_canary_filename.functionName` fest, damit er mit dem Datei- und Funktionsnamen des Skript-Eintrittspunkts übereinstimmt. Wenn Sie die Laufzeit `syn-python-selenium-1.0` verwenden, muss `functionName` `handler` sein. Wenn Sie ` syn-python-selenium-1.1` oder neuer verwenden, gilt diese Einschränkung für den Handlernamen nicht und Sie können den Canary auch in einem separaten Ordner (z. B. ` python/myFolder/my_canary_filename.py`) ablegen. Wenn Sie ihn in einem separaten Ordner speichern, geben Sie den entsprechenden Pfad in Ihrem Skript-Eintrittspunkt an (z. B. ` myFolder/my_canary_filename.functionName`). ## Ändern eines vorhandenen Selenium-Skripts zur Verwendung eines Synthetics-Canarys Sie können schnell ein vorhandenes Skript für Python und Selenium ändern, um als Canary verwendet zu werden. [Weitere Informationen zu Selenium finden Sie unter www.selenium.dev/.](https://www.selenium.dev/) In diesem Beispiel beginnen wir mit dem folgenden Selenium-Skript: ``` from selenium import webdriver def basic_selenium_script(): browser = webdriver.Chrome() browser.get('https://example.com') browser.save_screenshot('loaded.png') basic_selenium_script() ``` Für die Konvertierung sind die folgenden Schritte durchzuführen. **So konvertieren Sie ein Selenium-Skript für die Verwendung als Canary** 1. Ändern Sie die `import`-Anweisung, um Selenium aus dem ` aws_synthetics`-Modul zu verwenden: ``` from aws_synthetics.selenium import synthetics_webdriver as webdriver ``` Das Selenium-Modul von `aws_synthetics` stellt sicher, dass der Canary Metriken und Protokolle ausgeben, eine HAR-Datei generieren und mit anderen CloudWatch Synthetics-Funktionen arbeiten kann. 1. Erstellen Sie eine Handler-Funktion und rufen Sie Ihre Selenium-Methode auf. Der Handler ist die Eintrittsfunktion für das Skript. Wenn Sie `syn-python-selenium-1.0` verwenden, muss die Handler-Funktion den Namen `handler` haben. Wenn Sie `syn-python-selenium-1.1` oder neuer verwenden, kann die Funktion einen beliebigen Namen haben. Dieser Name muss jedoch mit dem Namen im Skript übereinstimmen. Wenn Sie `syn-python-selenium-1.1` oder neuer verwenden, können Sie Ihre Skripte außerdem in einem beliebigen Ordner ablegen und diesen Ordner als Teil des Handlernamens angeben. ``` def handler(event, context): basic_selenium_script() ``` Das Skript wurde jetzt aktualisiert und ist jetzt ein CloudWatch Synthetics-Kanarienvogel. Nachfolgend finden Sie das aktualisierte Skript: Das `webdriver` ist eine Instanz der Klasse [ SyntheticsWebDriver](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_Library_Python.html#CloudWatch_Synthetics_Library_Python_SyntheticsWebDriver)und der von zurückgegebene Browser `webdriver.Chrome()` ist eine Instanz von [ SyntheticsBrowser](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Synthetics_Canaries_Library_Python.html#CloudWatch_Synthetics_Library_Python_SyntheticsBrowser). ``` from aws_synthetics.selenium import synthetics_webdriver as webdriver def basic_selenium_script(): browser = webdriver.Chrome() browser.get('https://example.com') browser.save_screenshot('loaded.png') def handler(event, context): basic_selenium_script() ``` ## Änderung eines vorhandenen Puppeteer-Synthetics-Skripts zur Authentifizierung von nicht standardmäßigen Zertifikaten Ein wichtiger Anwendungsfall für Synthetics-Canarys ist die Überwachung Ihrer eigenen Endpunkte.. Wenn Sie einen Endpunkt überwachen möchten, der nicht für externen Datenverkehr bereit ist, kann diese Überwachung manchmal bedeuten, dass Sie nicht über ein ordnungsgemäßes Zertifikat verfügen, das von einer vertrauenswürdigen externen Zertifizierungsstelle signiert wurde. Zwei mögliche Lösungen für dieses Szenario lauten wie folgt: + Informationen zur Authentifizierung eines Client-Zertifikats finden Sie unter [So validieren Sie die Authentifizierung mit Amazon CloudWatch Synthetics — Teil 2.](https://aws.amazon.com/blogs/mt/how-to-validate-authentication-using-amazon-cloudwatch-synthetics-part-2/) + Informationen zur Authentifizierung eines selbstsignierten Zertifikats finden Sie unter [So validieren Sie die Authentifizierung mit selbstsignierten Zertifikaten](https://aws.amazon.com/blogs/mt/how-to-validate-authentication-with-self-signed-certificates-in-amazon-cloudwatch-synthetics/) in Amazon Synthetics CloudWatch Sie sind nicht auf diese beiden Optionen beschränkt, wenn Sie CloudWatch Synthetics Canaries verwenden. Sie können durch Erweiterung des Canary-Codes diese Features erweitern und Ihre Geschäftslogik hinzufügen. **Anmerkung** Bei Synthetics-Canarys, die auf Python-Laufzeiten ausgeführt werden, ist das ` --ignore-certificate-errors`-Flag von Haus aus aktiviert, sodass diese Canarys keine Probleme haben sollten, Seiten mit nicht standardmäßigen Zertifikatkonfigurationen zu erreichen. # Schreiben einer JSON-Konfiguration für den Blueprint Node.js Multi Checks Mit dem Blueprint Node.js für Mehrfachprüfungen können Sie Canaries erstellen, die mehrere Validierungsprüfungen innerhalb eines einzigen Canary-Laufs durchführen. Dieser Blueprint ist nützlich, wenn Sie mehrere Endpunkte testen, verschiedene Aspekte Ihrer Anwendung validieren oder nacheinander eine Reihe verwandter Prüfungen durchführen möchten. **Topics** + [Struktur der Stammkonfiguration](#root-configuration-structure) + [Globale Einstellungen](#global-settings) + [Variablen und Datenmanagement](#variables-data-management) + [Definitionen der Schritte](#step-definitions) + [Überprüfen Sie die Typen](#check-types) + [Authentifizierungsmethoden](#authentication-methods) + [Behauptungen und Validierung](#assertions-validation) + [Datenextraktion](#data-extraction) ## Struktur der Stammkonfiguration Die Root-Konfiguration definiert die Gesamtstruktur Ihres erweiterten API-Blueprint-Canary. **Eigenschaften des Schemas** | Eigenschaft | Typ | Erforderlich | Description | | --- | --- | --- | --- | | globalSettings | Objekt | Nein | Standardkonfigurationen, die auf alle Schritte angewendet wurden | | variables | Objekt | Nein | Schrittübergreifend wiederverwendbare Werte (max. 10) | | steps | Objekt | Ja | Erfassung von Überwachungsschritten (1—10 Schritte) | **Beispiel** ``` { "globalSettings": { "stepTimeout": 30000, "userAgent": "CloudWatch-Synthetics-Advanced/1.0" }, "variables": { "baseUrl": "https://api.example.com", "apiVersion": "v1" }, "steps": { "1": { "stepName": "healthCheck", "checkerType": "HTTP", "url": "${baseUrl}/health", "httpMethod": "GET" } } } ``` **Regeln für die Validierung** + Muss mindestens einen Schritt enthalten + Maximal 10 Schritte sind zulässig + Außer`globalSettings`, und sind keine weiteren Eigenschaften zulässig ` variables` `steps` ## Globale Einstellungen Globale Einstellungen bieten Standardkonfigurationen, die für alle Schritte gelten, sofern sie nicht auf Schrittebene überschrieben werden. **Eigenschaften** **Eigenschaften für globale Einstellungen** | Eigenschaft | Typ | Standard | Bereich | Description | | --- | --- | --- | --- | --- | | stepTimeout | Ganzzahl | 30000 | 5000-300000 | Standard-Timeout für alle Schritte (Millisekunden) | **Beispiel** ``` { "globalSettings": { "stepTimeout": 60000, } } ``` ## Variablen und Datenmanagement Mit Variablen können Sie wiederverwendbare Werte definieren, auf die in Ihrer gesamten Konfiguration mithilfe von `${variableName}` Syntax verwiesen werden kann. **Eigenschaften von Variablen** | Eigenschaft | Typ | Description | | --- | --- | --- | | Namen von Variablen | Zeichenfolge | Muss mit dem Muster übereinstimmen ^[a-zA-Z][a-zA-Z0-9\$1]\$1\$1 | | Variablenwerte | Zeichenfolge | Beliebiger Zeichenkettenwert | **Einschränkungen** + Maximal 10 Variablen pro Konfiguration + Variablennamen müssen mit einem Buchstaben beginnen + Variablennamen dürfen nur Buchstaben, Zahlen und Unterstriche enthalten + Die maximale Länge ist im Schema nicht angegeben **Beispiel** ``` { "variables": { "baseUrl": "https://api.example.com", "apiKey": "${AWS_SECRET:my-api-key}", "timeout": "30000", "userEmail": "test@example.com" } } ``` **Verwendung der Konfiguration** ``` { "steps": { "1": { "url": "${baseUrl}/users", "timeout": "${timeout}", "headers": { "Authorization": "Bearer ${apiKey}" } } } } ``` ## Definitionen der Schritte Die einzelnen Schritte definieren die einzelnen Überwachungsvorgänge. Jeder Schritt ist von 1 bis 10 nummeriert und beinhaltet eine bestimmte Art von Prüfung. *Allgemeine Eigenschaften von Schritten* | Eigenschaft | Typ | Erforderlich | Beschreibung | | --- | --- | --- | --- | | stepName | Zeichenfolge | Ja | Eindeutiger Bezeichner für den Schritt | | checkerType | Zeichenfolge | Ja | Art der Prüfung:HTTP,DNS,SSL, TCP | | extractors | Array | Nein | Konfiguration der Datenextraktion | *Überprüfung des Schrittnamens* + Muster - ^ [a-zA-Z] [A-zA-Z0-9\$1-] \$1\$1 + Maximale Länge: 64 Zeichen + Muss mit einem Buchstaben beginnen *Nummerierung der Schritte* + Die Schritte werden als Zeichenkettenschlüssel nummeriert: „1", „2",..., „10" + Muster: ^ ([1-9] \$110) \$1 + Mindestens 1 Schritt erforderlich + Maximal 10 Schritte sind zulässig *Beispiel* ``` { "steps": { "1": { "stepName": "loginAPI", "checkerType": "HTTP", "url": "https://api.example.com/login", "httpMethod": "POST" }, "2": { "stepName": "dnsCheck", "checkerType": "DNS", "domain": "example.com" } } } ``` ## Überprüfen Sie die Typen ### HTTP-Prüfungen Überwachen Sie Webendpunkte und profitieren Sie von APIs einer umfassenden Überprüfung von Anfragen und Antworten. **Erforderliche Eigenschaften** | Eigenschaft | Typ | Description | | --- | --- | --- | | url | Zeichenfolge | Ziel-URL (muss ein gültiges URI-Format haben) | | httpMethod | Zeichenfolge | HTTP-Methode: GETPOST,PUT, PATCH,DELETE,HEAD, OPTIONS | **Optionale Eigenschaften** | Eigenschaft | Typ | Standard | Bereich | Description | | --- | --- | --- | --- | --- | | timeout | Ganzzahl | 30000 | 5000-300000 | Zeitlimit für Anfragen (Millisekunden) | | waitTime | Ganzzahl | 0 | 0-60 | Verzögerung vor der Anfrage (Sekunden) | | headers | object | - | - | Benutzerdefinierte HTTP-Header | | body | Zeichenfolge | - | - | Hauptteil der Anfrage für POST/PUT Operationen | | authentication | object | - | - | Authentifizierungs-Konfiguration | | assertions | Array | - | - | Regeln für die Validierung von Antworten | **Beispiel** ``` { "stepName": "createUser", "checkerType": "HTTP", "url": "https://api.example.com/users", "httpMethod": "POST", "timeout": 15000, "headers": { "Content-Type": "application/json", "X-API-Version": "v1" }, "body": "{\"name\":\"John Doe\",\"email\":\"john@example.com\"}", "authentication": { "type": "API_KEY", "apiKey": "${AWS_SECRET:api-credentials}", "headerName": "X-API-Key" }, "assertions": [ { "type": "STATUS_CODE", "operator": "EQUALS", "value": 201 } ] } ``` ### DNS-Prüfungen Überprüfen Sie die DNS-Auflösung und zeichnen Sie Informationen auf. **Erforderliche Eigenschaften** | Eigenschaft | Typ | Description | | --- | --- | --- | | domain | Zeichenfolge | Abzufragender Domainname (Hostnamenformat) | **Optionale Eigenschaften** | Eigenschaft | Typ | Standard | Description | | --- | --- | --- | --- | | recordType | Zeichenfolge | „EIN“ | Typ des DNS-Eintrags: ACNAME,MX, TXT, NS | | nameserver | Zeichenfolge | - | Spezifischer DNS-Server, der abgefragt werden soll | | timeout | Ganzzahl | 30000 | Timeout für Abfragen (5000-300000 ms) | | port | Ganzzahl | 53 | DNS-Serverport (1-65535) | | protocol | Zeichenfolge | „UDP“ | Protokoll: UDP oder TCP | | assertions | Array | - | Regeln für die Überprüfung von DNS-Antworten | **Beispiel** ``` { "stepName": "dnsResolution", "checkerType": "DNS", "domain": "example.com", "recordType": "A", "nameserver": "8.8.8.8", "timeout": 10000, "assertions": [ { "type": "RECORD_VALUE", "operator": "CONTAINS", "value": "192.168" } ] } ``` ### SSL-Prüfungen Überwachen Sie den Zustand und die Konfiguration des SSL-Zertifikats. **Erforderliche Eigenschaften** | Eigenschaft | Typ | Description | | --- | --- | --- | | hostname | Zeichenfolge | Ziel-Hostname (Hostnamenformat) | **Optionale Eigenschaften** | Eigenschaft | Typ | Standard | Beschreibung | | --- | --- | --- | --- | | port | Ganzzahl | 443 | SSL-Port (1-65535) | | timeout | Ganzzahl | 30000 | Verbindungs-Timeout (5000-300000 ms) | | sni | boolesch | TRUE | Angabe des Servernamens | | verifyHostname | boolesch | TRUE | Überprüfung des Hostnamens | | allowSelfSigned | boolesch | FALSE | Akzeptieren Sie selbstsignierte Zertifikate | | assertions | Array | - | Regeln für die Validierung von Zertifikaten | **Beispiel** ``` { "stepName": "sslCertCheck", "checkerType": "SSL", "hostname": "secure.example.com", "port": 443, "sni": true, "verifyHostname": true, "assertions": [ { "type": "CERTIFICATE_EXPIRY", "operator": "GREATER_THAN", "value": 30, "unit": "DAYS" } ] } ``` ### TCP-Prüfungen Testen Sie die TCP-Port-Konnektivität und die Antwortvalidierung. **Erforderliche Eigenschaften** | Eigenschaft | Typ | Description | | --- | --- | --- | | hostname | Zeichenfolge | Ziel-Hostname (Hostnamenformat) | | port | Ganzzahl | Zielport (1-65535) | **Optionale Eigenschaften** | Eigenschaft | Typ | Standard | Beschreibung | | --- | --- | --- | --- | | timeout | Ganzzahl | 30000 | Gesamtzeitlimit (5000-300000 ms) | | connectionTimeout | Ganzzahl | 3000 | Verbindungs-Timeout (5000-300000 ms) | | readTimeout | Ganzzahl | 2000 | Timeout beim Lesen von Daten (5000-300000 ms) | | sendData | Zeichenfolge | - | Daten, die nach der Verbindung gesendet werden sollen | | expectedResponse | Zeichenfolge | - | Erwartete Antwortdaten | | encoding | Zeichenfolge | „UTF-8" | Datenkodierung:UTF-8,, ASCII HEX | | assertions | Array | - | Überprüfung der Verbindung und der Antwort | **Beispiel** ``` { "stepName": "databaseConnection", "checkerType": "TCP", "hostname": "db.example.com", "port": 3306, "connectionTimeout": 5000, "sendData": "SELECT 1", "expectedResponse": "1", "assertions": [ { "type": "CONNECTION_SUCCESSFUL", "value": true } ] } ``` ## Authentifizierungsmethoden **Keine Authentifizierung** ``` { "type": "NONE" } ``` **Grundlegende Authentifizierung** | Eigenschaft | Typ | Erforderlich | Beschreibung | | --- | --- | --- | --- | | type | Zeichenfolge | Ja | Muss "BASIC" sein. | | username | Zeichenfolge | Ja | Nutzername für die Authentifizierung | | password | Zeichenfolge | Ja | Passwort für die Authentifizierung | **Beispiel** ``` { "type": "BASIC", "username": "admin", "password": "${AWS_SECRET:basic-auth:password}" } ``` **API-Schlüsselauthentifizierung** | Eigenschaft | Typ | Erforderlich | Standard | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "API\$1KEY" sein. | | apiKey | Zeichenfolge | Ja | - | Wert des API-Schlüssels | | headerName | Zeichenfolge | Nein | „X-API-Schlüssel“ | Header-Name für den API-Schlüssel | **Beispiel** ``` { "type": "API_KEY", "apiKey": "${AWS_SECRET:api-credentials}", "headerName": "Authorization" } ``` **OAuth Kundenanmeldedaten** | Eigenschaft | Typ | Erforderlich | Standard | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "OAUTH\$1CLIENT\$1CREDENTIALS" sein. | | tokenUrl | Zeichenfolge | Ja | - | OAuth Token-Endpunkt-URL | | clientId | Zeichenfolge | Ja | - | OAuth Client-ID | | clientSecret | Zeichenfolge | Ja | - | OAuth Geheimes Client-Geheimnis | | scope | Zeichenfolge | Nein | - | OAuth Geltungsbereich | | audience | Zeichenfolge | Nein | - | OAuth Publikum | | resource | Zeichenfolge | Nein | - | OAuth Ressource | | tokenApiAuth | Array | Nein | - | Authentifizierungsmethoden der Token-API:BASIC\$1AUTH\$1HEADER, REQUEST\$1BODY | | tokenCacheTtl | Ganzzahl | Nein | 3600 | Token-Cache TTL (mindestens 60 Sekunden) | **Beispiel** ``` { "type": "OAUTH_CLIENT_CREDENTIALS", "tokenUrl": "https://auth.example.com/oauth/token", "clientId": "${AWS_SECRET:oauth-creds:client_id}", "clientSecret": "${AWS_SECRET:oauth-creds:client_secret}", "scope": "read write", "tokenCacheTtl": 7200 } ``` **AWS Signatur (Version 4)** | Eigenschaft | Typ | Erforderlich | Beschreibung | | --- | --- | --- | --- | | type | Zeichenfolge | Ja | Muss "SIGV4" sein. | | service | Zeichenfolge | Ja | Name des AWS Dienstes (z. B. „execute-api“) | | region | Zeichenfolge | Ja | AWS Region | | roleArn | Zeichenfolge | Ja | IAM-Rolle ARN zum Signieren | **Beispiel** ``` { "type": "SIGV4", "service": "execute-api", "region": "us-east-1", "roleArn": "arn:aws:iam::123456789012:role/SyntheticsRole" } ``` ## Behauptungen und Validierung ### HTTP-Assertionen **Zusicherungen im Statuscode** | Eigenschaft | Typ | Erforderlich | Beschreibung | | --- | --- | --- | --- | | type | Zeichenfolge | Ja | Muss "STATUS\$1CODE" sein. | | operator | Zeichenfolge | Ja | EQUALS, NOT\$1EQUALS, GREATER\$1THAN, LESS\$1THAN, IN\$1RANGE | | value | Ganzzahl | Bedingt | HTTP-Statuscode (100-599) | | rangeMin | Ganzzahl | Bedingt | Minimaler Bereichswert (für) IN\$1RANGE | | rangeMax | Ganzzahl | Bedingt | Maximaler Bereichswert (fürIN\$1RANGE) | ``` { "type": "STATUS_CODE", "operator": "EQUALS", "value": 200 } ``` **Behauptungen zur Antwortzeit** | Eigenschaft | Typ | Erforderlich | Standard | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "RESPONSE\$1TIME" sein. | | operator | Zeichenfolge | Ja | - | LESS\$1THAN, GREATER\$1THAN, EQUALS | | value | number | Ja | - | Zeitwert (mindestens 0) | | unit | Zeichenfolge | Nein | „MILLISEKUNDEN“ | Muss "MILLISECONDS" sein. | ``` { "type": "RESPONSE_TIME", "operator": "LESS_THAN", "value": 500, "unit": "MILLISECONDS" } ``` **Hauptaussagen** | Eigenschaft | Typ | Erforderlich | Beschreibung | | --- | --- | --- | --- | | type | Zeichenfolge | Ja | Muss "HEADER" sein. | | headerName | Zeichenfolge | Ja | Name des zu validierenden Headers | | operator | Zeichenfolge | Ja | EQUALS, NOT\$1EQUALS, CONTAINS, NOT\$1CONTAINS, REGEX\$1MATCH, EXIST | | value | Zeichenfolge/boolescher Wert | Bedingt | Erwarteter Wert (boolescher Wert für Operator) EXIST | ``` { "type": "HEADER", "headerName": "Content-Type", "operator": "CONTAINS", "value": "application/json" } ``` **Behauptungen im Hauptteil** | Eigenschaft | Typ | Erforderlich | Standard | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "BODY" sein. | | target | Zeichenfolge | Nein | „JSON“ | JSON oder TEXT | | path | Zeichenfolge | Bedingt | - | JSONPath (erforderlich für das JSON-Ziel) | | operator | Zeichenfolge | Ja | - | CONTAINS, NOT\$1CONTAINS, EQUALS, NOT\$1EQUALS, EXISTS | | value | Zeichenfolge/boolescher Wert | Ja | - | Erwarteter Wert (boolescher Wert für Operator) EXISTS | ``` { "type": "BODY", "target": "JSON", "path": "$.users[0].name", "operator": "EQUALS", "value": "John Doe" } ``` ### DNS-Assertionen **Behauptungen über Rekordwerte** | Eigenschaft | Typ | Erforderlich | Bereich | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "RECORD\$1VALUE" sein. | | operator | Zeichenfolge | Ja | - | EQUALS, NOT\$1EQUALS, CONTAINS, NOT\$1CONTAINS, REGEX\$1MATCH | | value | Zeichenfolge | Ja | - | Erwarteter Rekordwert | **Anzahl von Assertionen** | Eigenschaft | Typ | Erforderlich | Bereich | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "RECORD\$1COUNT" sein. | | operator | Zeichenfolge | Ja | - | EQUALS, GREATER\$1THAN, LESS\$1THAN | | value | Ganzzahl | Ja | ≥ 0 | Erwartete Anzahl (mindestens 0) | **Maßgebliche Behauptungen** | Eigenschaft | Typ | Erforderlich | Bereich | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "AUTHORITATIVE" sein. | | value | boolesch | Ja | - | Erwarteter maßgeblicher Status | **TTL-Assertionen** | Eigenschaft | Typ | Erforderlich | Bereich | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "TTL" sein. | | operator | Zeichenfolge | Ja | - | EQUALS, GREATER\$1THAN, LESS\$1THAN | | value | Ganzzahl | Ja | ≥ 0 | Erwartete TTL (mindestens 0) | ### SSL-Assertionen **Behauptungen zum Ablauf des Zertifikats** | Eigenschaft | Typ | Erforderlich | Standard | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "CERTIFICATE\$1EXPIRY" sein. | | operator | Zeichenfolge | Ja | - | GREATER\$1THAN, LESS\$1THAN | | value | Ganzzahl | Ja | - | Zeitwert (mindestens 0) | | unit | Zeichenfolge | Nein | „TAGE“ | DAYS, HOURS | **Behauptungen des Betreffenden des Zertifikats** | Eigenschaft | Typ | Erforderlich | Standard | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "CERTIFICATE\$1SUBJECT" sein. | | field | Zeichenfolge | Ja | - | Fachfeld:CN,O,OU,C, ST L | | operator | Zeichenfolge | Ja | - | CONTAINS, EQUALS, REGEX\$1MATCH | | value | Zeichenfolge | Ja | - | Erwarteter Feldwert | **Behauptungen des Zertifikatsausstellers** | Eigenschaft | Typ | Erforderlich | Standard | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "CERTIFICATE\$1ISSUER" sein. | | field | Zeichenfolge | Ja | - | Feld des Ausstellers:, CN O | | operator | Zeichenfolge | Ja | - | CONTAINS, EQUALS | | value | Zeichenfolge | Ja | - | Erwarteter Feldwert | ### TCP-Assertionen **Behauptungen über eine erfolgreiche Verbindung** | Eigenschaft | Typ | Erforderlich | Standard | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "CONNECTION\$1SUCCESSFUL" sein. | | value | boolesch | Ja | - | Erwarteter Verbindungsstatus | **Behauptungen zu Antwortdaten** | Eigenschaft | Typ | Erforderlich | Standard | Description | | --- | --- | --- | --- | --- | | type | Zeichenfolge | Ja | - | Muss "RESPONSE\$1DATA" sein. | | operator | Zeichenfolge | Ja | - | CONTAINS, EQUALS, NOT\$1CONTAINS, REGEX\$1MATCH, STARTS\$1WITH, ENDS\$1WITH | | value | Zeichenfolge | Ja | - | Erwartete Antwortdaten | | encoding | Zeichenfolge | Nein | „UTF-8" | UTF-8, ASCII, HEX | ## Datenextraktion Mit Extractors können Sie Daten aus Antworten erfassen, um sie in nachfolgenden Schritten oder zu Berichtszwecken zu verwenden. **Eigenschaften der Extraktion** | Eigenschaft | Typ | Erforderlich | Standard | Description | | --- | --- | --- | --- | --- | | name | Zeichenfolge | Ja | - | Variablenname für extrahierte Daten | | type | Zeichenfolge | Ja | - | Extraktionstyp: BODY | | path | Zeichenfolge | Nein | - | JSONPath zur Körperextraktion | | regex | Zeichenfolge | Nein | - | Muster für reguläre Ausdrücke | | regexGroup | Ganzzahl | Nein | 0 | Regex-Erfassungsgruppe (mindestens 0) | **Überprüfung des Namens der Extraktion** + Pattern: `^[a-zA-Z][a-zA-Z0-9_]*$` + Muss mit einem Buchstaben beginnen + Kann Buchstaben, Zahlen und Unterstriche enthalten **Einschränkung** — Die Substitution gilt nicht für Felder im Schema, die bestimmte ENUM-Werte haben **Extraktionstypen** ``` { "name": "userId", "type": "BODY", "path": "$.user.id" } ``` ``` { "stepName": "loginAndExtract", "checkerType": "HTTP", "url": "https://api.example.com/login", "httpMethod": "POST", "body": "{\"username\":\"test\",\"password\":\"pass\"}", "extractors": [ { "name": "textVariable", "type": "BODY", "path": "$.myvalue" } ] }, { "stepName": "substituteVariable", "checkerType": "HTTP", "url": "https://api.example.com/get/${textVariable}", "httpMethod": "GET", "assertions": [ { "type": "BODY", "target": "JSON", "path": "$.users[0].name", "operator": "EQUALS", "value": "${textVariable}" } ] } ```