

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.

# Testen der Veröffentlichung
<a name="release-management-release-testing"></a>

Release-Tests generieren und führen Testpläne aus, um Codeänderungen in realistischen Umgebungen zu validieren. Der Release-Test-Agent führt explorative UAT- und Regressionstests — funktionale Regression, User-Journey-Validierung, Integrationstests und Edge-Case-Exploration — für Ihre bereitgestellten Webanwendungen und REST-APIs durch.

## So funktionieren Release-Tests
<a name="how-release-testing-works"></a>

**Wichtig**  
**Beim Release-Testen werden echte Anfragen an Ihre Zielanwendung ausgeführt, einschließlich Schreiboperationen (POST, PUT, DELETE). Der Agent untersucht Endpunkte, sendet Formulare und testet die Fehlerbehandlung — durch diese Aktionen können Daten in der Zielanwendung erstellt, geändert oder gelöscht werden. Verwenden Sie diese Option nur, wenn Ihr Risikoprofil Änderungen im Rahmen der explorativen Tests zulässt. Stellen Sie sicher, dass Ihre Anwendungen explorative Schreibvorgänge ohne unbeabsichtigte Folgen wie das Senden von Kundenbenachrichtigungen, die Verarbeitung von Zahlungen oder das dauerhafte Löschen von Datensätzen tolerieren. Wir empfehlen, nicht auf Staging-Bereitstellungen zu setzen. Produktionsanwendungen sollten nur dann ins Visier genommen werden, wenn die Schreibvorgänge Ihrer Anwendung für automatische Tests sicher sind.

Wenn der Release-Test-Agent ausgelöst wird:

1. **Generiert einen Testplan ** — Erstellt einen Testplan auf der Grundlage von Codeänderungen oder einer vom Benutzer angegebenen Testabsicht. Wenn der Plan von einem Pull-Request oder Branch ausgelöst wird, zielt er auf die betroffene Funktionalität ab. Wenn der Test manuell oder im Chat ausgelöst wird, kannst du eine Testabsicht angeben, in der beschrieben wird, was überprüft werden soll. Der Plan umfasst funktionale Korrektheit, Integrationsverhalten und nutzerorientierte Szenarien.

1. **Führt Tests für eine laufende Anwendung aus ** — Anhand einer Ziel-URL (Webanwendung oder API-Endpunkt) untersucht der Agent die Anwendung und führt die generierten Tests aus. Bei Webanwendungen umfasst dies browserbasierte Benutzeroberflächeninteraktionen und visuelle Inspektionen. Bei APIs umfasst dies direkte HTTP-Endpunkttests, Schemavalidierung und Überprüfung der Fehlerbehandlung.

1. **Meldet Ergebnisse ** — Es werden Ergebnisse mit bestimmten Fehlern, beeinträchtigten Funktionen, Reproduktionsschritten und empfohlenen Korrekturen zurückgegeben.

Versionstests unterstützen Webanwendungen (React, Angular, Vue, servergerendert) und REST-APIs.

## Unterstützte Testtypen
<a name="supported-test-types"></a>
+ **UI-Tests ** — Browser-based Testen mit visuellen Interaktionen für Webanwendungen
+ **API-Tests ** — Direktes Testen von HTTP-Endpunkten für REST-APIs

## Definition von Testprofilen
<a name="defining-test-profiles"></a>

Testprofile definieren die Web- und API-Anwendungen, die Sie testen möchten, sowie die erforderlichen Konfigurationen. Jedes Testprofil spezifiziert eine Zielanwendung und ihren Testtyp.

Um ein Testprofil zu erstellen:

1. Navigieren Sie in der DevOps Agent-Web-App ** in der linken Navigationsleiste zu ** Release Manager.

1. Wählen Sie die ** Schaltfläche „Profile ** testen“.

1. Wählen ** Sie Testprofil hinzufügen**.

1. Füllen Sie das Formular mit den folgenden Angaben aus:
   + **Name ** — Ein beschreibender Name für das Testprofil (z. B. "MyApp Staging“)
   + **Ziel-URL ** — Die URL einer Staging- oder Testbereitstellung Ihrer Anwendung. Der Agent sendet echten HTTP-Verkehr einschließlich Schreiboperationen (POST, PUT, DELETE). Verwenden Sie keine Produktions-URLs, es sei denn, Sie verstehen und akzeptieren das Risiko einer Datenänderung.
   + **Testtyp ** — Wählen Sie entweder ** UI-Tests ** (browserbasiertes Testen mit visuellen Interaktionen) oder ** API-Tests ** (direktes Testen von HTTP-Endpunkten)

1. Wählen Sie Testprofil ** hinzufügen**, um zu speichern.

**Hinweis: ** Die Anwendung muss über das öffentliche Internet zugänglich sein. Private Netzwerkendpunkte werden derzeit nicht unterstützt.

## Tests von einem Testprofil aus ausführen
<a name="running-tests-from-a-test-profile"></a>

Auf der ** Seite ** Testprofile können Sie manuell einen Testlauf auslösen:

1. Suchen Sie Ihr Testprofil in der Liste.

1. Wählen Sie Testen ** starten aus**.

1. (Optional) Geben Sie unter Testabsicht spezifische Anweisungen an und geben Sie an, was ** getestet werden soll**. Zum Beispiel „Stellen Sie sicher, dass der Checkout-Prozess abgelaufene Coupons korrekt verarbeitet“ oder „Testen Sie das Benutzerregistrierungsformular mit ungültigen Eingaben“.

Der Agent erstellt einen Testplan, der auf Ihrer Absicht basiert (oder untersucht ihn umfassend, wenn keine Absicht angegeben wird), führt Tests durch und berichtet über die Ergebnisse im ** Abschnitt ** Release Manager unter den vorgeschlagenen Änderungen.

## Tests werden vom DevOps Agenten-Chat aus ausgeführt
<a name="running-tests-from-devops-agent-chat"></a>

Im DevOps Agenten-Chat können Sie Release-Tests anfordern. Bitten Sie den Agenten, Ihre Testprofile aufzulisten oder anzugeben, welches ausgeführt werden soll. Der Agent fragt Sie nach weiteren Informationen, z. B. was getestet werden soll oder auf welche Bereiche Sie sich konzentrieren sollten.

Beispiele:
+ „Meine Testprofile auflisten“
+ „Testprofil my-test-profile ausführen“
+ „Führen Sie einen Release-Test für meine Anwendung unter durch https://staging.myapp.com und überprüfen Sie den Zahlungsfluss“

Der Agent meldet den Fortschritt bei der Erkundung der Anwendung und gibt Ergebnisse mit spezifischen Ergebnissen, Screenshots (für UI-Tests) und Reproduktionsschritten zurück.

## Tests von Ihrer IDE aus ausführen
<a name="running-tests-from-your-ide"></a>

Von Kiro IDE oder Claude Code aus kann der Coding-Agent Release-Tests aufrufen:

Installieren Sie zunächst das [ Kiro Power ]() - oder [ Claude Code-Plugin. ]()
+ Geben Sie eine Testanforderung oder -absicht an, die beschreibt, was überprüft werden soll (z. B. „Stellen Sie sicher, dass der Anmeldeablauf nach dem Auth-Refactor funktioniert“)
+ Der Codierungsagent leitet die Testabsicht und ein Zieltestprofil an den Release-Test-Agent weiter
+ Der Release Testing Agent generiert Tests und führt sie aus und meldet dann die Ergebnisse zurück
+ Wenn Probleme entdeckt werden, bietet der Codierungsagent an, sie an Ort und Stelle zu beheben

**Hinweis: Das ** Testen gegen einen Pull-Request direkt von der IDE wird derzeit nicht unterstützt. Verwenden Sie ein Testprofil mit einer bereitgestellten Anwendungs-URL und geben Sie eine Testanforderung an, um sich auf die Tests zu konzentrieren.

## Testen Sie in CI/CD Pipelines
<a name="release-testing-in-cicd-pipelines"></a>

### GitHub Aktionen
<a name="github-actions"></a>

Die `aws-actions/devops-agent-release-testing@v1` GitHub Aktion löst den Release-Test-Agent nach der Bereitstellung aus und meldet die Ergebnisse als GitHub Check Run für Ihren Commit- oder Pull-Request.

#### Voraussetzungen
<a name="prerequisites"></a>
+ Ein [ Testprofil, das in Ihrem Agent Space ](#defining-test-profiles) konfiguriert ist
+ Ein in Ihrem Agentenbereich [DevOps Agent über Webhook aufrufen](configuring-integrations-and-knowledge-invoking-devops-agent-through-webhook.md) konfiguriertes

#### Schritt 1: GitHub Repository-Geheimnisse konfigurieren
<a name="step-1-configure-github-repository-secrets"></a>

Gehe in deinem GitHub Repository zu ** Einstellungen → Geheimnisse und Variablen → Aktionen → Repository-Geheimnisse ** und füge hinzu:


| Secret | Description | 
| --- | --- | 
| DEVOPS\_AGENT\_WEBHOOK\_URL | Die Webhook-URL aus Ihrem Agentenbereich | 
| DEVOPS\_AGENT\_WEBHOOK\_SECRET | Das geheime Webhook-Signaturgeheimnis aus Ihrem Agentenbereich | 

Informationen zum Erstellen eines Webhook-Endpunkts finden Sie unter. [DevOps Agent über Webhook aufrufen](configuring-integrations-and-knowledge-invoking-devops-agent-through-webhook.md)

#### Schritt 2: Fügen Sie die Aktion zu Ihrem Workflow hinzu
<a name="step-2-add-the-action-to-your-workflow"></a>

Fügen Sie den Schritt zum Release-Testen zu Ihrem Workflow hinzu (zum Beispiel`.github/workflows/release-tests.yml`):

```
name: Release Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

permissions:
  checks: write
  contents: read
  pull-requests: read

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Trigger Release Tests
        uses: aws-actions/devops-agent-qa@v1
        with:
          webhook-url: ${{ secrets.DEVOPS_AGENT_WEBHOOK_URL }}
          webhook-secret: ${{ secrets.DEVOPS_AGENT_WEBHOOK_SECRET }}
          test-profile-id: <YOUR_TEST_PROFILE_ID>
          test-requirement: <WHAT_TO_TEST>  # optional
        env:
          GITHUB_TOKEN: ${{ github.token }}
```

`<YOUR_TEST_PROFILE_ID>`Ersetzen Sie es durch die Testprofil-ID aus Ihrem Agentenbereich (beginnt mit`ki-`). Die `test-requirement` Eingabe ist optional. Verwenden Sie sie, um den Agenten auf bestimmte Bereiche zu konzentrieren (z. B. „Anmeldeablauf nach Auth-Refactor überprüfen“).

#### Eingaben für Aktionen
<a name="action-inputs"></a>


| Input | Erforderlich | Description | 
| --- | --- | --- | 
| Webhook-URL | Ja | Die Webhook-URL aus Ihrem Agentenbereich | 
| Webhook-Geheimnis | Ja | Das Webhook-Signaturgeheimnis für die Authentifizierung HMAC-SHA256  | 
| Testprofil-ID | Ja | Die auszulösende Testprofil-ID (beginnt mit) ki- | 
| Testanforderung | Nein | Optionaler Schwerpunktbereich für das Testen | 

#### Erforderliche Workflow-Berechtigungen
<a name="required-workflow-permissions"></a>


| Berechtigung | Grund | 
| --- | --- | 
| Inhalt: lesen | Erforderlich für actions/checkout private Repos | 
| Pull-Requests: lesen | Löst die PR-Nummer aus dem Merge-Commit-SHA auf | 

#### Funktionsweise
<a name="how-it-works"></a>

1. Ihr Workflow wird ausgelöst (z. B. nach der Bereitstellung in einer Staging-Umgebung).

1. Die Aktion erstellt einen Check Run (`in_progress`) für den Commit oder PR, der als ausstehende Prüfung angezeigt wird.

1. Die Aktion signiert und sendet einen Webhook an Ihren Agent Space.

1. Der Release-Test-Agent übernimmt die Aufgabe und führt Tests für Ihre Anwendung durch.

1. Die Ergebnisse werden als GitHub Prüflauf (pass/fail mit einer detaillierten Zusammenfassung) gemeldet.

Sie können die vollständigen Ausführungsdetails (Zeitplan, Testfälle, Screenshots für UI-Tests) in der DevOps Agenten-Web-App einsehen, die von Ihrem Agentenbereich aus verlinkt ist.

## Überprüfung der Testergebnisse
<a name="reviewing-test-results"></a>

Die Testergebnisse werden im ** Abschnitt „**Versionen“ der DevOps Agent-Web-App unter den vorgeschlagenen Änderungen angezeigt. Jeder Testlauf zeigt:
+ **Status ** — Abgeschlossen, Fehlgeschlagen oder In Bearbeitung
+ **Kategorie ** — Versionstests
+ **Dauer ** — Wie lange hat der Testlauf gedauert
+ **Quelle ** — Ob es manuell, über einen Chat oder über eine CI/CD Pipeline ausgelöst wurde

Wählen Sie einen Testlauf aus, um detaillierte Ergebnisse einschließlich bestimmter Testfehler, Screenshots (für UI-Tests), Reproduktionsschritte und empfohlene Korrekturen anzuzeigen.