View a markdown version of this page

Automatisieren Sie die Generierung von Lambda-Testereignissen mit Amazon Bedrock AgentCore - AWS Prescriptive Guidance
ZusammenfassungVoraussetzungen und EinschränkungenArchitekturToolsBewährte MethodenEpenFehlerbehebungZugehörige Ressourcen

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.

Automatisieren Sie die Generierung von Lambda-Testereignissen mit Amazon Bedrock AgentCore

Ishita Gupta und Kriti Gupta, Amazon Web Services

Zusammenfassung

Dieses Muster bietet einen AI-powered Ansatz zur automatischen Generierung umfassender Testfälle für AWS Lambda Funktionen mithilfe der generativen KI-Funktionen von Amazon Bedrock. Dieses Muster implementiert eine auf Amazon Bedrock bereitgestellte Architektur mit drei Agenten (Analyzer, Generator und Validator), die den tatsächlichen Lambda-Funktionscode analysiert AgentCore , um input/output Muster zu extrahieren, und positive, negative und Randfall-Testszenarien mit realistischen Daten generiert.

Die Architektur etabliert einen intelligenten Workflow, bei dem der Analyzer Agent Lambda-Code mithilfe von Amazon Bedrock abruft und analysiert, der Generator Agent Testfälle auf der Grundlage erlernter Muster erstellt und der Validator Agent die Qualität durch Deduplizierung und Rangfolge sicherstellt. Ein DynamoDB-based Amazon-Speicher ermöglicht kontinuierliches Lernen aus Benutzerfeedback und verbessert so im Laufe der Zeit die Genauigkeit der Testgenerierung. Amazon Cognito bietet eine sichere Benutzerauthentifizierung mit API-Autorisierung auf Basis von JSON Web Token (JWT). Amazon Bedrock Guardrails bieten schnelle Angriffsfilterung, Redaktion vertraulicher Informationen und Durchsetzung der Inhaltssicherheit bei allen Amazon Bedrock-API-Aufrufen. Wichtigste Funktionen:

  • Multi-Language Unterstützung: Python-, Java-, C#- und Ruby Lambda-Funktionen JavaScript/TypeScript

  • Intelligentes Code-Chunking: Teilt automatisch große Codebasen zur Analyse in überschaubare Blöcke auf

  • Parallele Verarbeitung: Gleichzeitige Amazon Bedrock-API-Aufrufe sorgen für eine schnellere Testgenerierung (5 gleichzeitige Worker für die Codeanalyse, parallele Testgenerierung pro Chunk)

  • Target-Specific Analyse: Konzentrieren Sie sich auf bestimmte Funktionen, Klassen oder Dateien im Lambda-Code

  • Pattern Learning: DynamoDB-based Amazon-Speicherspeicher mit zielspezifischem und globalem Musterspeicher

  • Vermeidung von Ablehnungen: Lernt aus abgelehnten Testfällen, um häufige Fehler zu vermeiden

  • Fortsetzungsmechanismus: Behandelt unvollständige Amazon Bedrock-Antworten mit automatischer Fortsetzung.

  • Muster ignorieren: Schließt Testdateien, Abhängigkeiten und Nicht-Codedateien von der Analyse aus.

  • Serverlose Bereitstellung: Läuft auf Amazon Bedrock mit Authentifizierung AgentCore Cognito-based

  • Sicherheitsvorkehrungen: Amazon Bedrock Guardrails für schnelle Angriffsfilterung, Redaktion personenbezogener Daten (PII), Inhaltssicherheit und Blockierung verweigerter Themen bei allen KI-Aufrufen

    Dieses Muster ist ideal für Entwicklungsteams und Organisationen, die Lambda-Tests beschleunigen, die Testabdeckung verbessern und während der Testgenerierung eine hohe Codequalität aufrechterhalten möchten. AI-assisted Dieses Muster verwendet von AWS verwaltete Services, um die Testerstellung zu vereinfachen, die Qualität durch Lernen zu verbessern und es zu skalieren, um den sich ändernden Testanforderungen gerecht zu werden.

Voraussetzungen und Einschränkungen

Voraussetzungen

Um dieses Muster erfolgreich zu implementieren, stellen Sie sicher, dass die folgenden Bedingungen erfüllt sind:

  • Ein aktives AWS-Konto — Ein AWS-Konto mit Berechtigungen zum Zugriff auf Lambda-Funktionen, zum Aufrufen von Amazon Bedrock-Modellen, zum Erstellen von DynamoDB-Tabellen, zum Verwalten von Cognito-Benutzerpools und zum Bereitstellen von Amazon Bedrock-Agenten. AgentCore

  • Zugriff auf das Amazon Bedrock-Modell — Anthropic Claude Sonnet 4 (us.anthropic.claude-sonnet-4-6) ist in Ihrer AWS-Region aktiviert. Anweisungen zur Einrichtung finden Sie unter Modellzugriff in der Amazon Bedrock-Dokumentation. https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html

  • Eine Entwicklungsumgebung, die besteht aus:

    - Python 3.11 oder höher

    - AWS CLI ist installiert und konfiguriert

    - Git zum Klonen des Repositorys

  • AWS-Lambda-Funktionen — Mindestens eine bereitgestellte Lambda-Funktion mit zugänglichem Quellcode zur Analyse. Die Funktion muss Quelldateien (.py, .js, .java, .cs, .rb) im Bereitstellungspaket enthalten, nicht nur kompilierten Bytecode.

  • Unterstützte Lambda-Laufzeiten:

    - Python 3.x (alle Versionen)

    - Node.js (JavaScript/TypeScript)

    - Java 8, 11, 17, 21 (erfordert .java-Quelldateien im Bereitstellungspaket)

    - .NET Core/.NET 6+ (C#) (benötigt .cs-Quelldateien im Bereitstellungspaket)

    - Ruby 2.7, 3.2

Einschränkungen

  • Dies erfordert Zugriff auf das Amazon Bedrock-Modell in der Region US-East-1 für Claude Sonnet 4.6. AWS Lambda-Funktionen können sich in jeder Region befinden.

  • Musterdaten in Amazon DynamoDB laufen nach 90 Tagen ab (konfigurierbar über Time to Live (TTL)), um die Relevanz zu wahren und die Kosten zu kontrollieren.

  • Java- und C#-Lambda-Funktionen müssen Quelldateien (.java, .cs) in den Bereitstellungspaketen enthalten. Compiled-only Pakete (.class, .dll) können nicht analysiert werden.

  • Das System implementiert eine speicherinterne Ratenbegrenzung pro Benutzer (5 Anfragen pro 60 Sekunden). Bei verteilten Bereitstellungen mit mehreren AgentCore Instanzen müsste die Ratenbegrenzung aus Konsistenzgründen auf DynamoDB oder Redis verschoben werden.

  • Einige AWS-Services sind nicht in allen AWS-Regionen verfügbar. Informationen zur Verfügbarkeit in Regionen finden Sie unter AWS-Services nach Regionen. Informationen zu bestimmten Endpunkten finden Sie auf der Seite Service-Endpunkte und Kontingente und wählen Sie den Link für den Service.

Versionen der Produkte

Architektur

Zielarchitektur

Das folgende Diagramm zeigt die Architektur und den Arbeitsablauf für dieses Muster:

In diesem Arbeitsablauf:

  1. Der Benutzer gibt Eingaben ein: Der Entwickler interagiert mit der lokal ausgeführten Streamlit-Benutzeroberfläche (app.py), gibt den Namen der Lambda-Funktion, optionale benutzerdefinierte Anweisungen für die Testgenerierung, einen Zielfilter, um sich auf bestimmte functions/classes /files zu konzentrieren, und ignoriert Muster, um Testdateien oder Abhängigkeiten auszuschließen.

  2. Cognito-Authentifizierung: Die Anwendung authentifiziert die Anfrage bei Cognito und gibt JWT (Token) an Streamlit zurück. ID/Access

  3. AgentCore API-Aufruf: Streamlit ruft die AgentCore API mit Bearer Token + Payload (Funktionsname, Filter, Anweisungen, Ignoriermuster) auf.

  4. JWT-Validierung: Die AgentCore API validiert JWT mithilfe der Cognito-Token-Signatur.

  5. Routing von Anfragen: Die AgentCore API leitet die Anfrage an den Lambda Test Generator-Workflow weiter (Runtime). AgentCore

  6. Codeanalyse-Anfrage: Analyzer Agent initiiert eine Anfrage, um den Code und die Metadaten der Ziel-Lambda-Funktion abzurufen.

  7. AWS-Authentifizierung für Lambda Access: Boto3 authentifiziert sich mithilfe der AgentCore Ausführungsrolle bei AWS und fordert Lesezugriffsberechtigungen an.

  8. AWS-Lambda-Codeabruf und -verarbeitung: Die IAM-Rolle autorisiert den Zugriff und ruft den Lambda-Funktionscode als ZIP-Datei ab, extrahiert Quelldateien, filtert Abhängigkeiten (node_modules, venv usw.) und Nicht-Code-Dateien heraus, wendet benutzerdefinierte Ignoriermuster an und zerlegt Code in überschaubare Teile.

  9. Amazon Bedrock-Authentifizierung: Der Boto3 Amazon Bedrock-Client authentifiziert sich mit AWS IAM für den Zugriff auf Amazon Bedrock und fordert Modellberechtigungen für die Verwendung von Anthropic Claude Sonnet 4.6 an.

  10. AI-Powered Codeanalyse: Die IAM-Rolle autorisiert und sendet Codeblöcke an Amazon Bedrock (us-east-1) mithilfe von Anthropic Claude Sonnet 4 (us.anthropic.claude-sonnet-4-6), wobei Amazon Bedrock Guardrail für schnelle Angriffsfilterung und Inhaltssicherheit angewendet wird. Amazon Bedrock führt eine erweiterte Regex + LLM-Analyse durch, um tatsächliche Eingabemuster (z. B. event ['body'], headers ['Authorization']), Ausgabemuster (z. B. statusCode, Antworttextstruktur), Abhängigkeiten, Fehlerbehandlungsmuster und Randfälle aus dem Code zu extrahieren.

  11. Analyseergebnisse werden verpackt: Analyzer Agent packt die Analyseergebnisse in ein AnalysisResult Objekt, das Codeblöcke, Eingabemuster, Ausgabemuster, Abhängigkeiten, Fehlermuster und Metadaten enthält, und übergibt sie dann an den Generator Agent.

  12. Der Testgenerierungsprozess beginnt: Der Generator Agent empfängt die Analyseergebnisse und initiiert eine Anforderung zur Generierung von Testfällen. Zunächst fragt er den DynamoDB-Speicher nach historischen Mustern ab, aus denen gelernt werden kann.

  13. Amazon DynamoDB-Authentifizierung für Speicherzugriff: Der Boto3 DynamoDB-Client authentifiziert sich bei AWS IAM, um Lesezugriffsberechtigungen zum Abrufen gespeicherter Muster zu erhalten.

  14. Historische Muster werden aus der Datenbank abgerufen: Die IAM-Rolle autorisiert und fragt die DynamoDB-Speichertabelle (Lambda-Testcase-Memory) ab, um zuvor akzeptierte Muster und abgelehnte Muster (fehlgeschlagene Tests mit Ablehnungsgründen) für die spezifische Lambda-Funktion abzurufen.

  15. Amazon Bedrock-Authentifizierung für die Testgenerierung: Der Boto3 Amazon Bedrock-Client authentifiziert sich erneut mit AWS IAM für den Amazon Bedrock-Zugriff, um Testfälle zu generieren.

  16. Generierung von KI-Testfällen: Die IAM-Rolle autorisiert und sendet Analyseergebnisse in Kombination mit Speichermustern an Amazon Bedrock. Amazon Bedrock generiert Testfallschemas mit realistischen Eingabeereignissen, die auf tatsächlichen Codemustern basieren. Dabei werden positive Tests (35%), negative Tests (35%) und Randfälle (30%) generiert. Die Generierung erfolgt aus Effizienzgründen pro Block parallel, wendet gelernte Muster aus dem Speicher an, vermeidet abgelehnte Muster und generiert bei großen Codebasen bei Bedarf Blöcke. Alle Bedrock converse () -Aufrufe beinhalten GuardRailConfig zur sofortigen Filterung von Angriffen, zur Bearbeitung personenbezogener Daten und zur Durchsetzung verweigerter Themen.

  17. Die Testvalidierung beginnt: Generator Agent leitet die generierten Testfallkandidaten zur Qualitätskontrolle, Deduplizierung und endgültigen Auswahl an den Validator Agent weiter.

  18. Der Validierungsprozess ist konfiguriert: Der Validator Agent empfängt die Testkandidaten und leitet den Validierungsprozess ein. Er fordert den Zugriff auf den DynamoDB-Speicher zur Bewertung und Validierung an.

  19. DynamoDB-Authentifizierung zur Validierung: Der Boto3 DynamoDB-Client authentifiziert sich bei AWS IAM für den Lesezugriff auf die Abfrage von Speichermustern zur Bewertung der Validierung.

  20. Die Testqualität wird bewertet: Die IAM-Rolle autorisiert und verwendet den DynamoDB-Speicher, um Testfälle auf der Grundlage früherer Mustererfolgsraten, Funktionsabdeckung und Codekomplexität zu bewerten. Validator führt die Strukturvalidierung, Deduplizierung mithilfe von Pattern-Hashing, Qualitätsbewertungen mit Konfidenzerhöhungen für Handlerfunktionen und Fehlerbehandlung durch, wählt die Diversität aus, um verschiedene Chunks und Testtypen abzudecken, und wählt die besten N Testfälle mit der höchsten Qualität und den unterschiedlichsten aus.

  21. Letzte Testfälle wurden zurückgegeben an AgentCore: Validator Agent gibt die endgültigen validierten Testfälle mit Metadaten (Konfidenzwerte, Beschreibungen, Eingabeereignisse, Kategorien) an den Hauptorchestrator zurück, der sie formatiert und an die Amazon AgentCore Bedrock-API zurücksendet

  22. An die Benutzeroberfläche übermittelte Ergebnisse: Die AgentCore API sendet die generierten Tests zurück an die Streamlit-Benutzeroberfläche, um sie mit Analysezusammenfassung, Generierungsmetadaten und Testfalldetails anzuzeigen.

  23. Benutzer überprüft und gibt Feedback: Der Entwickler überprüft die angezeigten Testfälle in der Streamlit-Benutzeroberfläche, bewertet jeden Test auf Qualität und Relevanz, akzeptiert gute Testfälle oder lehnt schlechte ab, mit bestimmten Ablehnungsgründen (missing_auth_headers, wrong_status_code, unrealistic_data, missing_required_fields, incorrect_event_source usw.) und optionalen benutzerdefinierten Anmerkungen, die die Ablehnung erläutern, und sendet dann Feedback.

  24. Feedback wird an das System übermittelt: Streamlit UI sendet das gesammelte Feedback (accepted/rejected Status, Ablehnungsgründe, benutzerdefinierte Notizen) an die AgentCore API (save_feedback).

  25. AgentCore leitet Feedback weiter: Die AgentCore API ruft den Validator-Agenten auf, der Logik zum Speichern von Feedback in DynamoDB enthält.

  26. Der Prozess zur Speicherung des Feedbacks beginnt: Der Validator Agent initiiert den Prozess zum Speichern des Feedbacks.

  27. Der DynamoDB-Schreibzugriff ist authentifiziert: Der Boto3 DynamoDB-Client authentifiziert sich bei AWS IAM (AgentCore Execution Role), um Schreibzugriffsberechtigungen zum Speichern von Feedbackmustern zu erhalten.

  28. Lernmuster werden gespeichert: Die IAM-Rolle autorisiert und speichert Benutzerfeedback in der DynamoDB-Speichertabelle. Jedes Muster wird mit einem zusammengesetzten Partitionsschlüssel (function_name #target_function oder function_name #GLOBAL), einem zusammengesetzten Sortierschlüssel (FEEDBACK# accepted/rejected #PATTERN #hash), einem Muster-Hash für die Deduplizierung, Testtyp, Eingabemusterstruktur, Feedback-Status, Ablehnungsgrund (falls abgelehnt), benutzerdefinierten Notizen, Nutzungsanzahl, Erfolgsrate, Zeitstempel und TTL von 90 Tagen für die automatische Bereinigung gespeichert. Diese gespeicherten Daten ermöglichen es dem System, aus dem Feedback der Benutzer zu lernen und die zukünftige Testgenerierung zu verbessern.

Automatisierung und Skalierung

Dieses Muster skaliert automatisch mithilfe der von AWS verwalteten Services. Amazon Bedrock verarbeitet KI-Inferenzen auf Abruf mit einem Kontextfenster von 200.000 Token und einer Ausgabe von 64.000 Tokens pro Anruf. Amazon DynamoDB verwendet eine On-Demand-Abrechnung, die sich automatisch an die Verkehrsmuster anpasst. Das System verwendet parallele Verarbeitung aus Geschwindigkeitsgründen. Der Analyzer Agent führt 5 gleichzeitige Bedrock-Aufrufe durch, um Codeblöcke zu analysieren (ThreadPoolExecutor mit max_workers=5), während der Generator Agent Chunks parallel zu 5 Workern verarbeitet. Ein Fortsetzungsmechanismus behandelt unvollständige Antworten, indem Anfragen automatisch wiederholt werden. Die Ratenbegrenzung (5 Anfragen pro 60 Sekunden pro Benutzer) verhindert den Kostenmissbrauch durch übermäßige Bedrock-API-Aufrufe.

Die Kostenoptimierung umfasst eine TTL-based Bereinigung, bei der Muster entfernt werden, die älter als 90 Tage sind, zusammengesetzte Schlüsselabfragen mit begins_with () für sofortige Suchvorgänge ohne Tabellenscans sowie BatchWriteItem Operationen, die DynamoDB-Schreibvorgänge um etwa 90% reduzieren. Die Leistung hängt von der Funktionsgröße ab, kleine Funktionen (unter 10 Dateien) generieren 10 Testfälle in 30—60 Sekunden, mittlere Funktionen (10—50 Dateien) benötigen 1—3 Minuten und große Funktionen (über 50 Dateien) benötigen 3—5 Minuten, obwohl die Verwendung von Zielfiltern zur Fokussierung auf bestimmte Codeabschnitte die Zeit um 50-70% reduziert.

Tools

AWS-Services

  • Amazon Bedrock — Bietet generative KI-Funktionen über Anthropic Claude Sonnet 4 für Codeanalyse, Testgenerierung, Validierung und Zusammenfassung von Ablehnungen. Verwendet immer die Region us-east-1 für den Modellzugriff.

  • Amazon Bedrock AgentCore — Bietet serverlose Agentenlaufzeit für die Bereitstellung und das Hosting des Backends für die Testgenerierung mit automatischer Skalierung, OAuth-based Autorisierung und Beobachtbarkeit. CloudWatch

  • Amazon Bedrock Guardrails — Bietet ML-based Sicherheitsfilter für alle Bedrock-API-Aufrufe, einschließlich sofortiger Angriffserkennung (HOHE Stärke), Inhaltsfilterung, PII-Anonymisierung (E-Mail, Telefon, Name), Blockierung von keys/private keys/JWT AWS-Zugriffstoken und Durchsetzung verweigerter Themen (Generierung von Exploit-Code, Ausgabe des Rohquellcodes). Bereitgestellt über. CloudFormation

  • AWS CloudFormation — Automatisiert die komplette Infrastrukturbereitstellung, einschließlich DynamoDB-Tabelle, Cognito-Benutzerpool, Amazon Bedrock Guardrail mit Versionierung und IAM-Ausführungsrolle für. AgentCore

  • Amazon Cognito — Bietet Benutzerauthentifizierung mit E-Mail-basierter Anmeldung, Ausgabe von JWT-Tokens und sicherer API-Autorisierung für das Backend. AgentCore

  • Amazon DynamoDB — Speichert akzeptierte und abgelehnte Testmuster mit Nutzungsstatistiken für kontinuierliches Lernen und Verbessern. Verwendet zusammengesetzte Schlüssel (function_target, pattern_sk) für Zero-Scan-Abfragen und zielspezifische Musterspeicherung.

  • AWS Lambda — Quelle des Funktionscodes für die Analyse. Die API ruft Code und Konfiguration ab. GetFunction Das Tool unterstützt Python-, Java Node.js -, .NET- und Ruby-Laufzeiten.

Andere Tools

  • Python 3.11+ — Laufzeitumgebung für die Anwendungs- und Agenten-Orchestrierung.

  • Streamlit — Web-based Benutzeroberfläche für Authentifizierung, Testgenerierung, Erfassung von Feedback und Überwachung des Systemstatus.

  • Boto3 — AWS-SDK für Python zur Interaktion mit Lambda-, Amazon Bedrock-, DynamoDB- und Cognito-Diensten.

Code-Repository

Der Code für dieses Muster ist in Github - Lambda Test Event Generator verfügbar.

Bewährte Methoden

Dieses Muster implementiert die folgenden Best Practices:

  • Verwendet IAM-Richtlinien mit geringsten Rechten für den Zugriff auf AWS Lambda (schreibgeschützt), Amazon Bedrock (Aufrufen), Amazon DynamoDB () und Amazon Cognito (Authentifizierung). query/write

  • Implementieren Sie zielspezifisches Musterlernen mit globalem Fallback, um die Testgenauigkeit zu verbessern.

  • Aktivieren Sie DynamoDB TTL für die automatische Bereinigung alter Muster (90 Tage), um die Speicherkosten unter Kontrolle zu halten.

  • Verwenden Sie Zero-Scan-Abfragen mit zusammengesetzten Schlüsseln (function_target, pattern_sk) für einen schnellen Musterabruf.

  • Wenden Sie Ignoriermuster an, um Testdateien, Abhängigkeiten und Dateien, die nichts mit Code zu tun haben, von der Analyse auszuschließen.

  • Verwenden Sie mehrsprachiges Code-Chunking mit AST-Parsing (Abstract Syntax Tree) (Python) und Regex-Mustern (Java, C#, JS, Ruby).

  • Speichern Sie Muster mit tatsächlichen Werten (nicht nur mit Struktur) für eine echte Deduplizierung.

  • Stellen Sie das Backend auf Amazon Bedrock AgentCore für serverlose Skalierung und verwaltete Infrastruktur bereit.

  • Authentifizieren Sie Benutzer über Amazon Cognito mit einer JWT-Token-Validierung bei jeder API-Anfrage.

  • Wenden Sie Amazon Bedrock Guardrails auf alle Converse () -Aufrufe an, um schnell Angriffe zu filtern, PII zu redigieren, vertrauliche Daten (AWS-Schlüssel, private Schlüssel, JWTs) zu blockieren und die Durchsetzung verweigerter Themen zu verhindern.

  • Bereinigen Sie die Analyseergebnisse, bevor Sie sie an die Benutzer zurückgeben. Alle Rohquellcode-Blöcke werden aus den Antworten entfernt, sodass der Lambda-Quellcode niemals die Laufzeitgrenze verlässt. AgentCore

  • Validieren Sie alle API-Eingaben mit Regex-Mustern und Längenbeschränkungen (Funktionsname maximal 170 Zeichen, benutzerdefinierte Anweisungen maximal 2000 Zeichen, maximal 50 Ignoriermuster), um Injektion und Missbrauch zu verhindern.

  • Implementieren Sie eine Ratenbegrenzung pro Benutzer (5 Anfragen pro 60 Sekunden), um Kostenmissbrauch durch übermäßige Bedrock-API-Aufrufe zu verhindern.

  • Bereinigen Sie Fehlermeldungen, bevor Sie sie an die Benutzer zurückgeben — interne Dateipfade, AWS-SDK-Details und Infrastrukturinformationen werden in den Fehlerantworten niemals preisgegeben.

Beachten Sie die folgenden zusätzlichen bewährten Methoden:

  • Geben Sie konkrete Gründe für Feedback an, wenn Sie Testfälle ablehnen, um die Lerngenauigkeit zu verbessern.

  • Generieren Sie iterativ (2-3 mal) Tests für dieselbe Funktion, damit das System lernen und sich verbessern kann.

  • Stellen Sie benutzerdefinierte Anweisungen bereit, wenn Sie bestimmte Testszenarien oder Datenformate benötigen.

  • Aktivieren Sie IAM Access Analyzer, um Ressourcenberechtigungen zu überwachen und unbeabsichtigte Zugriffe zu erkennen.

  • Beginnen Sie mit kleinen Lambda-Funktionen, um das System zu verstehen, bevor Sie große Codebasen analysieren.

  • Überprüfen Sie die IAM-Richtlinien regelmäßig und entfernen Sie ungenutzte Berechtigungen.

  • Verwenden Sie sichere Passwortrichtlinien und aktivieren Sie Cognito AdvancedSecurityMode für die Erkennung von Bedrohungen.

Epen

AufgabeDescriptionErforderliche Fähigkeiten

Klonen Sie das Repository

Klonen Sie das GitHub Repository auf Ihr lokales System und navigieren Sie zum Projektverzeichnis:

git clone https://github.com/aws-samples/sample-lambda-test-event-generator.git

cd sample-lambda-test-event-generator

Dieses Repository enthält die Python-Anwendungs-, CloudFormation Vorlagen- und Konfigurationsdateien.

App-Developer

Konfigurieren Sie die AWS-Anmeldeinformationen.

Konfigurieren Sie Ihre AWS-Anmeldeinformationen, damit die AWS-CLI mit Ihrem AWS-Konto interagieren kann und die Anwendung auf Lambda-Funktionen zugreifen kann, die Sie testen möchten.

Sie können dies mit dem AWS-CLI-Konfigurationsbefehl tun:

aws configure

Wenn Sie dazu aufgefordert werden, geben Sie die folgenden Informationen an:

  • AWS-Zugriffsschlüssel-ID: Ihr AWS-Zugriffsschlüssel

  • Geheimer AWS-Zugriffsschlüssel: Ihr geheimer AWS-Zugriffsschlüssel

  • Name der Standardregion: Die AWS-Region, in der Sie die Ressourcen bereitstellen möchten (z. B.us-east-1)

  • Standardausgabeformat: Das bevorzugte Ausgabeformat (z. B.json)

App-Developer
AufgabeDescriptionErforderliche Fähigkeiten

Stellen Sie die Infrastruktur mithilfe von bereit CloudFormation.

  1. Stellen Sie die komplette Backend-Infrastruktur (DynamoDB-, Cognito-, IAM-Rollen) mithilfe der bereitgestellten Vorlage bereit. CloudFormation Führen Sie den folgenden Befehl in Ihrer CLI aus:

    aws cloudformation create-stack \
      --stack-name lambda-test-generator-infra \
      --template-body file://cloudformation/complete-infrastructure.yaml \
      --capabilities CAPABILITY_NAMED_IAM \
      --region us-east-1

  2. Warten Sie, bis die Stack-Bereitstellung abgeschlossen ist:

    aws cloudformation wait stack-create-complete \
      --stack-name lambda-test-generator-infra \
      --region us-east-1

  3. Ruft alle Ausgaben ab:

    aws cloudformation describe-stacks \
      --stack-name lambda-test-generator-infra \
      --query 'Stacks[0].Outputs' \
      --output table

Was wird erstellt:

  • DynamoDB-Tabelle mit aktiviertem TTL, Point-in-Time-Recovery und serverseitiger Verschlüsselung.

  • Cognito-Benutzerpool mit E-Mail-Authentifizierung, AdvancedSecurityMode ENFORCED, optionalem MFA (TOTP) und Benutzererstellung nur für Administratoren.

  • Amazon Bedrock Guardrail mit sofortiger Angriffsfilterung, PII-Schwärzung, Inhaltsfilterung und Blockierung verweigerter Themen.

  • IAM-Ausführungsrolle für Richtlinien AgentCore mit den geringsten Rechten, einschließlich Bedrock: Permission. ApplyGuardrail

Anmerkung

Der Stack erstellt alle erforderlichen Ressourcen. Stellen Sie sicher, dass die CloudFormation Vorlage erfolgreich abgeschlossen wurde, bevor Sie mit dem nächsten Schritt fortfahren.

App-Developer

Exportieren Sie Konfigurationsvariablen.

Exportieren Sie alle Werte aus den CloudFormation Stack-Ausgaben als Umgebungsvariablen:

export AGENTCORE_ROLE_ARN=$(aws cloudformation describe-stacks \
      --stack-name lambda-test-generator-infra \
      --query 'Stacks[0].Outputs[?OutputKey==`AgentCoreExecutionRoleArn`].OutputValue' \
      --output text)

export DISCOVERY_URL=$(aws cloudformation describe-stacks \
      --stack-name lambda-test-generator-infra \
      --query 'Stacks[0].Outputs[?OutputKey==`DiscoveryUrl`].OutputValue' \
      --output text)

export CLIENT_ID=$(aws cloudformation describe-stacks \
      --stack-name lambda-test-generator-infra \
      --query 'Stacks[0].Outputs[?OutputKey==`ClientId`].OutputValue' \
      --output text)

export DYNAMODB_TABLE=$(aws cloudformation describe-stacks \
      --stack-name lambda-test-generator-infra \
      --query 'Stacks[0].Outputs[?OutputKey==`DynamoDBTableName`].OutputValue' \
      --output text)

export COGNITO_POOL_ID=$(aws cloudformation describe-stacks \
      --stack-name lambda-test-generator-infra \
      --query 'Stacks[0].Outputs[?OutputKey==`UserPoolId`].OutputValue' \
      --output text)

export BEDROCK_GUARDRAIL_ID=$(aws cloudformation describe-stacks \
  --stack-name lambda-test-generator-infra \
  --query 'Stacks[0].Outputs[?OutputKey==`BedrockGuardrailId`].OutputValue' \
  --output text)

export BEDROCK_GUARDRAIL_VERSION=$(aws cloudformation describe-stacks \
  --stack-name lambda-test-generator-infra \
  --query 'Stacks[0].Outputs[?OutputKey==`BedrockGuardrailVersion`].OutputValue' \
  --output text)

Diese Variablen werden in den nachfolgenden Schritten für die AgentCore Konfiguration und die Erstellung von.env-Dateien verwendet.

AWS-Administrator
AufgabeDescriptionErforderliche Fähigkeiten

Erstellen Sie eine virtuelle Umgebung.

  1. Erstellen und aktivieren Sie eine virtuelle Python-Umgebung, um Projektabhängigkeiten zu isolieren:

    python3 -m venv venv

source venv/bin/activate

  2. Installieren Sie die erforderlichen Python-Pakete aus der Anforderungsdatei:

    pip install -r requirements.txt

    Dadurch werden alle erforderlichen Bibliotheken installiert, einschließlich boto3 für das AWS-SDK, python-dotenv für die Umgebungskonfiguration, bedrock-agentcore-runtime für die Integration und Streamlit für die Benutzeroberfläche. AgentCore

    Anmerkung

    Die virtuelle Umgebung muss jedes Mal aktiviert (mit) verwendet werden, wenn Sie eine neue Terminalsitzung öffnen, um die Anwendung auszuführensource venv/bin/activate.

App-Developer

Konfiguration und Bereitstellung AgentCore.

  • Konfigurieren Sie den AgentCore Agenten:

    agentcore configure \
  --entrypoint main.py \
  --name lambda_test_generator \
  --requirements-file requirements.txt \
  --region us-east-1 \
  --execution-role $AGENTCORE_ROLE_ARN

  • Wenn Sie dazu aufgefordert werden:

    1. Bereitstellungstyp: 1 (Direct Code Deploy — kein Docker erforderlich)

    2. Python-Version: 2 (PYTHON_3_11 oder wählen Sie Ihre spezielle Python-Version aus)

    3. S3-Bucket: Drücken Sie die Eingabetaste (automatisch erstellen)

    4. OAuth-Autorisierer: ja

    5. Discovery-URL: Fügen Sie den Wert $DISCOVERY_URL ein

    6. Client-IDs: Fügen Sie den $CLIENT_ID-Wert ein

    7. Publikum: Drücken Sie die Eingabetaste (leer lassen)

    8. Bereiche: Drücken Sie die Eingabetaste (leer lassen)

    9. Benutzerdefinierte Ansprüche: Drücken Sie die Eingabetaste (lassen Sie das Feld leer)

    10. Header anfordern: ja

    11. Header: Autorisierung

    12. Speicher: s (skip — mit DynamoDB)

  • Stellen Sie den Agenten bereit:

    agentcore deploy \
  --env DYNAMODB_TABLE_NAME=$DYNAMODB_TABLE \
  --env AWS_REGION=us-east-1 \
  --env BEDROCK_GUARDRAIL_ID=$BEDROCK_GUARDRAIL_ID \
  --env BEDROCK_GUARDRAIL_VERSION=$BEDROCK_GUARDRAIL_VERSION

  • Rufen Sie die AgentCore Runtime-ID und den Endpunkt ab:

    RUNTIME_ID=$(agentcore status | grep "Agent ARN:" | sed 's/.*runtime\///' | sed 's/[│ ].*//')
AGENTCORE_ENDPOINT="https://bedrock-agentcore-runtime.us-east-1.amazonaws.com/agents/${RUNTIME_ID}/endpoints/DEFAULT"
App-Developer

Erstellen Sie eine ENV-Datei für die lokale Entwicklung.

Erstellen Sie eine .env-Datei im Stammverzeichnis des Projekts mit allen Konfigurationswerten:

cat > .env << EOF
AWS_REGION=us-east-1
DYNAMODB_TABLE_NAME=$DYNAMODB_TABLE
COGNITO_POOL_ID=$COGNITO_POOL_ID
COGNITO_CLIENT_ID=$CLIENT_ID
COGNITO_REGION=us-east-1
AGENTCORE_ENDPOINT=$AGENTCORE_ENDPOINT
BEDROCK_GUARDRAIL_ID=$BEDROCK_GUARDRAIL_ID
BEDROCK_GUARDRAIL_VERSION=$BEDROCK_GUARDRAIL_VERSION
EOF

Testen Sie die Konnektivität zu AWS-Services:

aws dynamodb describe-table --table-name $DYNAMODB_TABLE
aws bedrock list-foundation-models --region us-east-1

Beide Befehle sollten erfolgreiche Antworten zurückgeben. Wenn Sie auf Berechtigungsfehler stoßen, überprüfen Sie, ob die IAM-Richtlinien ordnungsgemäß konfiguriert sind.

App-Developer
AufgabeDescriptionErforderliche Fähigkeiten

Erstellen Sie einen neuen Cognito-Benutzer.

Der Cognito-Benutzerpool ist aus Sicherheitsgründen so konfiguriert, dass Benutzer nur von Administratoren erstellt werden, sodass sich Benutzer nicht selbst registrieren können. Erstellen Sie einen Benutzer über die AWS-CLI mithilfe der Cognito-Pool-ID und der Client-ID, die aus den Stack-Ausgaben exportiert wurden. CloudFormation Erstellen Sie einen neuen Benutzer (user@example.comersetzen Sie ihn durch Ihre E-Mail):

aws cognito-idp admin-create-user \
  --user-pool-id $COGNITO_POOL_ID \
  --username user@example.com \
  --user-attributes Name=email,Value=user@example.com Name=email_verified,Value=true \
  --temporary-password '[PASSWORD]!' \
  --region us-east-1

Lege ein permanentes Passwort fest (mindestens 8 Zeichen, muss Groß- und Kleinbuchstaben und eine Zahl enthalten):

aws cognito-idp admin-set-user-password \
  --user-pool-id $COGNITO_POOL_ID \
  --username user@example.com \
  --password '[PASSWORD]!' \
  --permanent \
  --region us-east-1

Verwenden Sie diese Anmeldeinformationen, um sich im nächsten Schritt über die Streamlit-Benutzeroberfläche anzumelden.

App-Developer
AufgabeDescriptionErforderliche Fähigkeiten

Starten Sie Streamlit UI.

Starten Sie die Anwendung:

streamlit run app.py

Die Benutzeroberfläche wird in Ihrem Standardbrowser unter geöffnet http://localhost:8501

Melden Sie sich mit den im vorherigen Schritt erstellten Anmeldeinformationen an

App-Developer

Konfigurieren Sie die Generierungsoptionen

Konfigurieren Sie auf der Benutzeroberfläche die folgenden Optionen:

  1. Name der Lambda-Funktion oder ARN: Geben Sie die Ziel-Lambda-Funktionskennung ein

  2. Zielfilter (optional): Geben Sie eine Funktion, Klasse oder Datei an, auf die Sie sich konzentrieren möchten (z. B.,validate_user,UserService) auth.py

  3. Muster ignorieren (optional): Fügen Sie auszuschließende Datei- oder Ordnermuster hinzu, eines pro Zeile:

    • tests/- Ignoriere das Testverzeichnis

    • *.test.js- Ignoriere Testdateien

    • mock_data/- Ignoriere Scheindaten

  4. Benutzerdefinierte Anweisungen (optional): Fügen Sie spezifische Testanforderungen hinzu

App-Developer

Generieren Sie Testfälle.

Klicken Sie auf die Schaltfläche „Testfälle generieren“. Das System führt folgende Aktionen aus:

  1. Authentifizieren Sie sich AgentCore mit dem Cognito JWT-Token.

  2. Rufen Sie den Lambda-Code von AWS ab.

  3. Wenden Sie Ignoriermuster an, um unerwünschte Dateien auszuschließen.

  4. Chunk-Code mithilfe sprachspezifischer Strategien.

  5. Wenden Sie den Zielfilter an, falls angegeben.

  6. Analysieren Sie den Code mit Amazon Bedrock.

  7. Fragen Sie DynamoDB nach erlernten Mustern ab.

  8. Generieren Sie Testfälle.

  9. Validieren und bewerten Sie Testfälle.

App-Developer

Überprüfen Sie die generierten Tests.

Überprüfen Sie jeden generierten Testfall, der Folgendes beinhaltet:

  • Typ: Positiv (gültige Eingaben), Negativ (ungültige Eingaben) oder Edge (Randbedingungen)

  • Beschreibung: Was der Test bestätigt

  • Testdaten: Die eigentliche Nutzlast des Testereignisses

DevOps Ingenieur, App-Entwickler

Geben Sie Feedback.

Geben Sie für jeden Testfall Feedback:

Um einen Testfall zu akzeptieren:

  • Klicken Sie auf die Schaltfläche „Akzeptieren“

Um einen Testfall abzulehnen:

  1. Klicken Sie auf die Schaltfläche „Ablehnen“

  2. Wählen Sie einen Ablehnungsgrund aus der Drop-down-Liste aus oder fügen Sie einen benutzerdefinierten Grund hinzu

  3. Klicken Sie auf die Schaltfläche „Ablehnung senden“

Testingenieur

Speichern Sie das Feedback im Speicher.

Nach Überprüfung aller Testfälle:

  1. Klicken Sie auf die Schaltfläche „Gesamtes Feedback im Speicher speichern“

  2. Das System überprüft, ob für alle abgelehnten Fälle Gründe angegeben wurden

  3. Das Feedback wird an die AgentCore API gesendet, die an den Validator Agent weitergeleitet wird.

  4. Feedback wird stapelweise mit einem Muster-Hash zur Deduplizierung in DynamoDB gespeichert.

  5. Sehen Sie sich die Feedback-Zusammenfassung mit den Zählungen an accepted/rejected

Testingenieur

Iterieren Sie, um Verbesserungen zu erzielen.

Generieren Sie noch 2-3 Mal Tests für dieselbe Funktion, um die Qualität zu verbessern:

  • Das System ruft gelernte Muster von DynamoDB ab

  • Die Qualität verbessert sich mit jeder Iteration auf der Grundlage Ihres Feedbacks

  • Verwenden Sie den Zielfilter für gezielte Tests an bestimmten Komponenten

  • Verwenden Sie Ignoriermuster, um irrelevanten Code auszuschließen und die Generierungsqualität zu verbessern

Anmerkung

Das Lernsystem wird bei wiederholter Verwendung effektiver. Jeder Feedback-Zyklus hilft der KI, Ihre Testpräferenzen zu verstehen und relevantere Testfälle für Ihre Lambda-Funktionen zu generieren.

App-Developer
AufgabeDescriptionErforderliche Fähigkeiten

Rufen Sie die AgentCore API direkt auf.

Rufen Sie zur Automatisierung und Integration das AgentCore Backend direkt mithilfe von API-Aufrufen mit Cognito-Authentifizierung auf.

Holen Sie sich ein Cognito-Token:

TOKEN=$(agentcore identity get-cognito-inbound-token)

Testgenerierung aufrufen:

agentcore invoke --bearer-token "$TOKEN" '{"action": "generate_test_cases", "function_name": "your-lambda-function", "num_test_cases": 10,"custom_instructions": "Focus on authentication scenarios", "target_filter": "validate_user","ignore_patterns": ["tests/", "*.test.js"] }'

Oder mit Curl:

curl -X POST "$AGENTCORE_ENDPOINT" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "action": "generate_test_cases", "function_name": "your-lambda-function", "num_test_cases": 10}'
App-Developer
AufgabeDescriptionErforderliche Fähigkeiten

Überwachen Sie DynamoDB-Muster und verfolgen Sie die Kosten.

  1. Fragen Sie die DynamoDB-Tabelle ab, um die akzeptierten Muster zu überprüfen und zu verstehen, was das System gelernt hat:

    aws dynamodb query \
  --table-name $DYNAMODB_TABLE \
  --key-condition-expression "function_target = :ft AND begins_with(pattern_sk, :prefix)" \
  --expression-attribute-values '{":ft":{"S":"my-function#GLOBAL"},":prefix":{"S":"FEEDBACK#accepted"}}'

    my-functionErsetzen Sie ihn durch Ihren tatsächlichen Lambda-Funktionsnamen, um Muster anzuzeigen, die für diese Funktion spezifisch sind.

  2. Verfolgen Sie den Ressourcenverbrauch, um die Kosten zu optimieren:

    • AWS Cost Explorer: Überwachen Sie die Gesamtausgaben für Bedrock-, DynamoDB- und Lambda-Services

    • Amazon Bedrock: Überprüfen Sie die Token-Nutzung und die Kennzahlen zu API-Aufrufen in der Bedrock-Konsole

    • DynamoDB: Überprüfen Sie die Anforderungsmetriken, die verbrauchte Kapazität und die Speichernutzung.

    • AgentCore: Überwachen Sie die Laufzeitmetriken und die Anzahl der Aufrufe der Agenten in CloudWatch

  3. Verwenden Sie CloudWatch Protokolle, um Probleme zu diagnostizieren und das Systemverhalten zu überwachen:

    • AgentCore Protokolle: 

      aws logs tail /aws/bedrock-agentcore/runtimes/lambda_test_generator --follow

    • Anwendungsfehler: Überprüfen Sie Fehler und Ausnahmen auf Anwendungsebene

    • Bedrock-API-Antworten: Analysieren Sie die Antworten des KI-Modells und den Token-Verbrauch

    • DynamoDB-Operationen: Überwachen Sie read/write Muster und Drosselungsereignisse

Anmerkung

Eine regelmäßige Überwachung hilft bei der Identifizierung von Möglichkeiten zur Kostenoptimierung und stellt sicher, dass das System weiterhin effektiv lernt. Die TTL-Konfiguration in Ihrer DynamoDB-Tabelle bereinigt automatisch alte Muster und hilft so, die Speicherkosten im Laufe der Zeit zu verwalten.

AWS-Administrator
AufgabeDescriptionErforderliche Fähigkeiten

Löschen Sie die bereitgestellten Ressourcen.

Um alle bereitgestellten Ressourcen zu entfernen:

Löschen Sie den AgentCore Agenten:

agentcore destroy

Löschen Sie den CloudFormation Stack (löscht die DynamoDB-Tabelle, den Cognito-Benutzerpool und die IAM-Rolle):

aws cloudformation delete-stack 
\ --stack-name lambda-test-generator-infra 
\ --region us-east-1
AWS-Administrator

Fehlerbehebung

ProblemLösung

Fehler „Zugriff verweigert“ beim Abrufen des Lambda-Codes

  • Stellen Sie sicher, dass die IAM-Berechtigungen lambda:GetFunction und lambda:GetFunctionConfiguration für die Lambda-Zielfunktion enthalten

  • Überprüfen Sie Ihre AWS-CLI-Anmeldeinformationen

    aws sts get-caller-identity

„DynamoDB-Schreibfehler“

  • Stellen Sie sicher, dass der Tabellenname in Ihrer .env Datei mit dem bereitgestellten Tabellennamen übereinstimmt

  • Überprüfen Sie die CloudFormation Ausgaben:

    aws cloudformation describe-stacks --stack-name lambda-test-generator-infra --query 'Stacks[0].Outputs[?OutputKey=DynamoDBTableName].OutputValue' --output text

  • Oder verifizieren Sie direkt:

    aws dynamodb describe-table --table-name $DYNAMODB_TABLE

Es wurden keine Testfälle generiert

Mögliche Ursachen und Lösungen:

  • Auf den Lambda-Funktionscode kann nicht zugegriffen werden: Überprüfen Sie die IAM-Berechtigungen für den Lambda-Zugriff

  • Das Lambda-Bereitstellungspaket enthält nur kompilierten Code: .class .dll Dateien ohne Quelldateien können nicht analysiert werden

  • Alle Dateien wurden nach Ignoriermustern herausgefiltert: Überprüfen Sie Ihre Ignoriermuster und passen Sie sie an

  • Benutzerdefinierte Anweisungen sind zu restriktiv: Vereinfache oder entferne benutzerdefinierte Anweisungen

  • Stellen Sie sicher, dass die Lambda-Funktion vorhanden ist:

    aws lambda get-function --function-name <name>

Java/C# Lambda zeigt „Kein Quellcode gefunden“

Für Java- und C#-Lambdas sind Quelldateien im Bereitstellungspaket erforderlich:

Java (Maven):

  1. Fügen Sie die Konfiguration für die Quelleneinbindung hinzu pom.xml (siehedocs/JAVA_SETUP.md)

  2. Erstellen Sie Ihre Lambda-Funktion neu und stellen Sie sie erneut bereit

C# (.NET):

  1. .csDateien in die Build-Konfiguration einbeziehen (siehedocs/CSHARP_SETUP.md)

  2. Erstellen Sie Ihre Lambda-Funktion neu und stellen Sie sie erneut bereit

DynamoDB-Schreibfehler

  • Überprüfen Sie die DynamoDB-Berechtigungen und den Tabellenstatus:

  • Stellen Sie sicher, dass die IAM-Richtlinie Folgendes umfasst: dynamodb:PutItem dynamodb:BatchWriteItem

  • Überprüfen Sie den Tabellenstatus: 

    aws dynamodb describe-table --table-name $DYNAMODB_TABLE

    Der Tabellenname enthält das Stack-Namensuffix. Verwenden Sie den Wert aus Ihren CloudFormation Ausgaben oder der ENV-Datei.

  • Aktivieren Sie CloudWatch Logs for DynamoDB, um detaillierte Fehlermeldungen anzuzeigen

Langsame Testgenerierung

Generierungsgeschwindigkeit optimieren:

  1. Verwenden Sie den Zielfilter, um sich auf bestimmte Funktionen zu konzentrieren (50-70% schneller)

  2. Fügen Sie Ignoriermuster hinzu, um Testdateien, Abhängigkeiten und irrelevanten Code auszuschließen

  3. Reduzieren Sie die Codegröße, indem Sie nicht benötigte Dateien vor der Analyse herausfiltern

AgentCore: „Agent nicht gefunden“

Stellen Sie sicher, dass der Agent eingesetzt wurde:

agentcore status

agentcore configure list

AgentCore: „Erlaubnis verweigert“ zur Laufzeit

Stellen Sie sicher, dass die Ausführungsrolle die richtigen Richtlinien hat:

aws iam list-role-policies --role-name agentcore-exec-lambda-test-generator-infra

Cognito: „Ungültiger Benutzername oder Passwort“

Vergewissern Sie sich, dass Ihre Anmeldeinformationen korrekt sind. Sie können einen neuen Benutzer mithilfe des Ablaufs „Konto erstellen“ der Streamlit-Benutzeroberfläche oder über die AWS-CLI erstellen:

aws cognito-idp admin-create-user --user-pool-id <POOL_ID> --username <username> --temporary-password '<password>' --region us-east-1
aws cognito-idp admin-set-user-password --user-pool-id <POOL_ID> --username <username> --password '<password>' --permanent --region us-east-1

Warnung „Bedrock Guardrail nicht konfiguriert“ in den Protokollen

Verify BEDROCK_GUARDRAIL_ID und BEDROCK_GUARDRAIL_VERSION Umgebungsvariablen sind in der Bereitstellung festgelegt. AgentCore

Überprüfen Sie die CloudFormation Ausgaben: 

aws cloudformation describe-stacks --stack-name lambda-test-generator-infra --query 'Stacks[0].Outputs[?OutputKey==`BedrockGuardrailId`].OutputValue' --output text

Fehler „Ratenlimit überschritten“

Das System beschränkt sich auf 5 Anfragen pro 60 Sekunden pro Benutzer. Warten Sie die angegebene Zeit, bevor Sie es erneut versuchen. Passen Sie für Produktionsanwendungen mit höherem Durchsatz die RATE_LIMIT_MAX_REQUESTS RATE_LIMIT_WINDOW Konstanten in der Datei main.py an.

Zugehörige Ressourcen

AWS-Dokumentation