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.
# Tutorial: Verwenden von Lambda mit Amazon SQS
In diesem Tutorial erstellen Sie eine Lambda-Ereignisfunktion, die Nachrichten aus einer [Amazon Simple Queue Service (Amazon SQS) -Warteschlange](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html) verarbeitet. Die Lambda-Ereignisfunktion wird immer dann ausgeführt, wenn der Warteschlange eine neue Nachricht hinzugefügt wird. Die Funktion schreibt die Nachrichten in einen Amazon CloudWatch Logs-Stream. Das folgende Diagramm zeigt die AWS -Ressourcen, die Sie zur Durchführung des Tutorials verwenden.
Führen Sie für dieses Tutorial die folgenden Schritte aus:
1. Erstellen Sie eine Lambda-Ereignisfunktion, die Nachrichten in CloudWatch Logs schreibt.
1. Erstellen einer Amazon SQS-Warteschlange
1. Erstellen Sie eine Zuordnung von Ereignisquellen in Lambda. Die Zuordnung der Ereignisquelle liest die Amazon SQS SQS-Warteschlange und ruft Ihre Lambda-Ereignisfunktion auf, wenn eine neue Nachricht hinzugefügt wird.
1. Testen Sie das Setup, indem Sie Nachrichten zu Ihrer Warteschlange hinzufügen und die Ergebnisse in Logs überwachen. CloudWatch
## Voraussetzungen
### Installieren Sie das AWS Command Line Interface
Wenn Sie das noch nicht installiert haben AWS Command Line Interface, folgen Sie den Schritten unter [Installieren oder Aktualisieren der neuesten Version von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html), um es zu installieren.
Das Tutorial erfordert zum Ausführen von Befehlen ein Befehlszeilenterminal oder eine Shell. Verwenden Sie unter Linux und macOS Ihre bevorzugte Shell und Ihren bevorzugten Paketmanager.
**Anmerkung**
In Windows werden einige Bash-CLI-Befehle, die Sie häufig mit Lambda verwenden (z. B. `zip`), von den integrierten Terminals des Betriebssystems nicht unterstützt. Um eine Windows-integrated Version von Ubuntu und Bash zu erhalten, [installieren Sie das Windows-Subsystem für Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10).
## Erstellen der Ausführungsrolle
Eine [Ausführungsrolle](lambda-intro-execution-role.md) ist eine AWS Identity and Access Management (IAM-) Rolle, die einer Lambda-Ereignisfunktion Zugriffsberechtigungen AWS-Services und Ressourcen gewährt. Damit Ihre Funktion Elemente aus Amazon SQS lesen kann, fügen Sie die **AWSLambdaSQSQueueExecutionRole**Berechtigungsrichtlinie bei.
**So erstellen Sie eine Ausführungsrolle und fügen eine Amazon-SQS-Berechtigungsrichtlinie hinzu**
1. Öffnen Sie die Seite [Roles (Rollen)](https://console.aws.amazon.com/iam/home#/roles) in der IAM-Konsole.
1. Wählen Sie **Rolle erstellen** aus.
1. Wählen Sie unter **Vertrauenswürdiger Entitätstyp** die Option **AWS -Service** aus.
1. Wählen Sie unter **Anwendungsfall** die Option **Lambda** aus.
1. Wählen Sie **Weiter** aus.
1. Geben Sie im Suchfeld **Berechtigungsrichtlinien** die Zeichenfolge **AWSLambdaSQSQueueExecutionRole** ein.
1. Wählen Sie die **AWSLambdaSQSQueueExecutionRole**Richtlinie aus und klicken Sie dann auf **Weiter**.
1. Geben Sie unter **Rollendetails** für **Rollenname** den Namen **lambda-sqs-role** ein und wählen Sie anschließend **Rolle erstellen** aus.
Schreiben Sie sich nach der Erstellung der Rolle den Amazon-Ressourcennamen (ARN) Ihrer Ausführungsrolle auf. Sie werden ihn in späteren Schritten noch benötigen.
## Erstellen Sie die Event-Funktion
Erstellen Sie eine Lambda-Ereignisfunktion, die Ihre Amazon SQS SQS-Nachrichten verarbeitet. Der Funktionscode protokolliert den Hauptteil der Amazon SQS-Nachricht in CloudWatch Logs.
Dieses Tutorial verwendet die Node.js 24-Runtime, aber wir haben auch Beispielcode in anderen Runtime-Sprachen bereitgestellt. Sie können die Registerkarte im folgenden Feld auswählen, um Code für die gewünschte Laufzeit anzusehen. Der JavaScript Code, den Sie in diesem Schritt verwenden, befindet sich im ersten Beispiel, das auf der **JavaScript**Registerkarte angezeigt wird.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Nutzen eines SQS-Ereignisses mit Lambda unter Verwendung von .NET.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
using Amazon.Lambda.Core;
using Amazon.Lambda.SQSEvents;
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace SqsIntegrationSampleCode
{
public async Task FunctionHandler(SQSEvent evnt, ILambdaContext context)
{
foreach (var message in evnt.Records)
{
await ProcessMessageAsync(message, context);
}
context.Logger.LogInformation("done");
}
private async Task ProcessMessageAsync(SQSEvent.SQSMessage message, ILambdaContext context)
{
try
{
context.Logger.LogInformation($"Processed message {message.Body}");
// TODO: Do interesting work based on the new message
await Task.CompletedTask;
}
catch (Exception e)
{
//You can use Dead Letter Queue to handle failures. By configuring a Lambda DLQ.
context.Logger.LogError($"An error occurred");
throw;
}
}
}
```
------
#### [ Go ]
**SDK für Go V2**
Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Nutzen eines SQS-Ereignisses mit Lambda unter Verwendung von Go.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package integration_sqs_to_lambda
import (
"fmt"
"github.com/aws/aws-lambda-go/events"
"github.com/aws/aws-lambda-go/lambda"
)
func handler(event events.SQSEvent) error {
for _, record := range event.Records {
err := processMessage(record)
if err != nil {
return err
}
}
fmt.Println("done")
return nil
}
func processMessage(record events.SQSMessage) error {
fmt.Printf("Processed message %s\n", record.Body)
// TODO: Do interesting work based on the new message
return nil
}
func main() {
lambda.Start(handler)
}
```
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Nutzen eines SQS-Ereignisses mit Lambda unter Verwendung von Java.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.SQSEvent;
import com.amazonaws.services.lambda.runtime.events.SQSEvent.SQSMessage;
public class Function implements RequestHandler {
@Override
public Void handleRequest(SQSEvent sqsEvent, Context context) {
for (SQSMessage msg : sqsEvent.getRecords()) {
processMessage(msg, context);
}
context.getLogger().log("done");
return null;
}
private void processMessage(SQSMessage msg, Context context) {
try {
context.getLogger().log("Processed message " + msg.getBody());
// TODO: Do interesting work based on the new message
} catch (Exception e) {
context.getLogger().log("An error occurred");
throw e;
}
}
}
```
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/blob/main/integration-sqs-to-lambda).
Konsumieren eines SQS-Ereignisses mit Lambda unter Verwendung. JavaScript
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
exports.handler = async (event, context) => {
for (const message of event.Records) {
await processMessageAsync(message);
}
console.info("done");
};
async function processMessageAsync(message) {
try {
console.log(`Processed message ${message.body}`);
// TODO: Do interesting work based on the new message
await Promise.resolve(1); //Placeholder for actual async work
} catch (err) {
console.error("An error occurred");
throw err;
}
}
```
Konsumieren eines SQS-Ereignisses mit Lambda unter Verwendung. TypeScript
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { SQSEvent, Context, SQSHandler, SQSRecord } from "aws-lambda";
export const functionHandler: SQSHandler = async (
event: SQSEvent,
context: Context
): Promise => {
for (const message of event.Records) {
await processMessageAsync(message);
}
console.info("done");
};
async function processMessageAsync(message: SQSRecord): Promise {
try {
console.log(`Processed message ${message.body}`);
// TODO: Do interesting work based on the new message
await Promise.resolve(1); //Placeholder for actual async work
} catch (err) {
console.error("An error occurred");
throw err;
}
}
```
------
#### [ PHP ]
**SDK für PHP**
Es gibt noch mehr dazu. GitHub Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Nutzen eines SQS-Ereignisses mit Lambda unter Verwendung von PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
logger = $logger;
}
/**
* @throws InvalidLambdaEvent
*/
public function handleSqs(SqsEvent $event, Context $context): void
{
foreach ($event->getRecords() as $record) {
$body = $record->getBody();
// TODO: Do interesting work based on the new message
}
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Nutzen eines SQS-Ereignisses mit Lambda unter Verwendung von Python.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
def lambda_handler(event, context):
for message in event['Records']:
process_message(message)
print("done")
def process_message(message):
try:
print(f"Processed message {message['body']}")
# TODO: Do interesting work based on the new message
except Exception as err:
print("An error occurred")
raise err
```
------
#### [ Ruby ]
**SDK für Ruby**
Es gibt noch mehr GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Nutzen eines SQS-Ereignisses mit Lambda unter Verwendung von Ruby.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
def lambda_handler(event:, context:)
event['Records'].each do |message|
process_message(message)
end
puts "done"
end
def process_message(message)
begin
puts "Processed message #{message['body']}"
# TODO: Do interesting work based on the new message
rescue StandardError => err
puts "An error occurred"
raise err
end
end
```
------
#### [ Rust ]
**SDK für Rust**
Es gibt noch mehr dazu GitHub. Das vollständige Beispiel sowie eine Anleitung zum Einrichten und Ausführen finden Sie im Repository mit [Serverless-Beispielen](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda).
Nutzen eines SQS-Ereignisses mit Lambda unter Verwendung von Rust.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
use aws_lambda_events::event::sqs::SqsEvent;
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
async fn function_handler(event: LambdaEvent) -> Result<(), Error> {
event.payload.records.iter().for_each(|record| {
// process the record
tracing::info!("Message body: {}", record.body.as_deref().unwrap_or_default())
});
Ok(())
}
#[tokio::main]
async fn main() -> Result<(), Error> {
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
// disable printing the name of the module in every log line.
.with_target(false)
// disabling time is handy because CloudWatch will add the ingestion time.
.without_time()
.init();
run(service_fn(function_handler)).await
}
```
------
**So erstellen Sie eine Node.js Lambda-Ereignisfunktion**
1. Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir sqs-tutorial
cd sqs-tutorial
```
1. Kopieren Sie den JavaScript Beispielcode in eine neue Datei mit dem Namen`index.js`.
1. Erstellen Sie ein Bereitstellungspaket mit dem folgenden `zip`-Befehl.
```
zip function.zip index.js
```
1. Erstellen Sie eine Lambda-Ereignisfunktion mit dem Befehl [AWS CLI create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html). Geben Sie für den `role`-Parameter den ARN der Ausführungsrolle ein, die Sie zuvor erstellt haben.
**Anmerkung**
Die Lambda-Ereignisfunktion und die Amazon SQS SQS-Warteschlange müssen sich in derselben befinden. AWS-Region
```
aws lambda create-function --function-name ProcessSQSRecord \
--zip-file fileb://function.zip --handler index.handler --runtime nodejs24.x \
--role arn:aws:iam::{{111122223333}}:role/lambda-sqs-role
```
## Testen Sie die Event-Funktion
Rufen Sie Ihre Lambda-Ereignisfunktion manuell mit dem `invoke` AWS CLI Befehl und einem Amazon SQS SQS-Beispielereignis auf.
**So rufen Sie die Lambda-Ereignisfunktion mit einem Beispielereignis auf**
1. Speichern Sie die folgende JSON als Datei mit dem Namen `input.json`. Dieses JSON simuliert ein Ereignis, das Amazon SQS möglicherweise an Ihre Lambda-Ereignisfunktion sendet, die die eigentliche Nachricht aus der Warteschlange `"body"` enthält. In diesem Beispiel lautet die Nachricht `"test"`.
**Example Amazon-SQS-Ereignis**
Dies ist ein Testereignis. Nachricht und Kontonummer müssen nicht geändert werden.
```
{
"Records": [
{
"messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
"receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...",
"body": "test",
"attributes": {
"ApproximateReceiveCount": "1",
"SentTimestamp": "1545082649183",
"SenderId": "AIDAIENQZJOLO23YVJ4VO",
"ApproximateFirstReceiveTimestamp": "1545082649185"
},
"messageAttributes": {},
"md5OfBody": "098f6bcd4621d373cade4e832627b4f6",
"eventSource": "aws:sqs",
"eventSourceARN": "arn:aws:sqs:us-east-1:111122223333:my-queue",
"awsRegion": "us-east-1"
}
]
}
```
1. [Führen Sie den folgenden Invoke-Befehl aus.](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/invoke.html) AWS CLI Dieser Befehl gibt CloudWatch Logs in der Antwort zurück. Weitere Informationen über das Abrufen von Protokollen finden Sie unter [Zugriffs-Logs mit dem AWS CLI](monitoring-cloudwatchlogs-view.md#monitoring-cloudwatchlogs-cli).
```
aws lambda invoke --function-name ProcessSQSRecord --payload file://input.json out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
Die **cli-binary-format** Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie `aws configure set cli-binary-format raw-in-base64-out` aus. Weitere Informationen finden Sie unter [Von AWS CLI unterstützte globale Befehlszeilenoptionen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) im *AWS Command Line Interface -Benutzerhandbuch für Version 2*.
1. Suchen Sie in der Antwort nach dem Protokoll `INFO`. Hier protokolliert die Lambda-Ereignisfunktion den Nachrichtentext. Sie sollten Protokolle sehen, die wie folgt aussehen:
```
2023-09-11T22:45:04.271Z 348529ce-2211-4222-9099-59d07d837b60 INFO Processed message test
2023-09-11T22:45:04.288Z 348529ce-2211-4222-9099-59d07d837b60 INFO done
```
## Erstellen einer Amazon-SQS-Warteschlange
Erstellen Sie eine Amazon SQS SQS-Warteschlange, die die Lambda-Ereignisfunktion als Ereignisquelle verwenden kann. Die Lambda-Ereignisfunktion und die Amazon SQS SQS-Warteschlange müssen sich in derselben befinden. AWS-Region
**So erstellen Sie eine Warteschlange**
1. Öffnen Sie die [Amazon-SQS-Konsole](https://console.aws.amazon.com/sqs).
1. Wählen Sie **Create queue** (Warteschlange erstellen) aus.
1. Geben Sie einen Namen für die Warteschlange ein. Übernehmen Sie bei allen anderen Optionen die Standardeinstellungen.
1. Wählen Sie **Create queue** (Warteschlange erstellen) aus.
Notieren Sie sich nach dem Erstellen der Warteschlange ihren ARN. Sie benötigen dies im nächsten Schritt, wenn Sie die Warteschlange mit Ihrer Lambda-Ereignisfunktion verknüpfen.
## Konfigurieren der Ereignisquelle
Connect die Amazon SQS SQS-Warteschlange mit Ihrer Lambda-Ereignisfunktion, indem Sie eine [Ereignisquellenzuordnung](invocation-eventsourcemapping.md) erstellen. Die Zuordnung der Ereignisquelle liest die Amazon SQS SQS-Warteschlange und ruft Ihre Lambda-Ereignisfunktion auf, wenn eine neue Nachricht hinzugefügt wird.
Verwenden Sie den Befehl create-event-source-mapping, um eine Zuordnung zwischen Ihrer Amazon SQS SQS-Warteschlange und Ihrer Lambda Event Function zu [erstellen](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-event-source-mapping.html) AWS CLI . Beispiel:
```
aws lambda create-event-source-mapping --function-name ProcessSQSRecord --batch-size 10 \
--event-source-arn arn:aws:sqs:{{us-east-1:111122223333:my-queue}}
```
Verwenden Sie den Befehl [list-event-source-mappings](https://awscli.amazonaws.com/v2/documentation/api/2.1.29/reference/lambda/list-event-source-mappings.html), um eine Liste Ihrer Zuordnungen von Ereignisquellen abzurufen. Beispiel:
```
aws lambda list-event-source-mappings --function-name ProcessSQSRecord
```
## Senden einer Testnachricht
**Um eine Amazon SQS SQS-Nachricht an die Lambda Event Function zu senden**
1. Öffnen Sie die [Amazon-SQS-Konsole](https://console.aws.amazon.com/sqs).
1. Wählen Sie die Warteschlange aus, die Sie zuvor erstellt haben.
1. Wählen Sie **Nachrichten senden und empfangen**.
1. Geben Sie unter **Nachrichtentext** eine Testnachricht ein (z. B. „Dies ist eine Testnachricht.“).
1. Klicken Sie auf **Send Message (Nachricht senden)**.
Lambda fragt die Warteschlange nach Aktualisierungen ab. Wenn eine neue Nachricht vorliegt, ruft Lambda Ihre Funktion mit diesen neuen Ereignisdaten aus der Warteschlange auf. Wenn der Funktions-Handler ohne Ausnahmen zurückgegeben wird, betrachtet Lambda die Nachricht als erfolgreich verarbeitet und beginnt mit dem Lesen neuer Nachrichten in der Warteschlange. Nach erfolgreicher Verarbeitung einer Nachricht löscht Lambda diese automatisch aus der Warteschlange. Wenn der Handler eine Ausnahme auslöst, betrachtet Lambda den Nachrichten-Batch als nicht erfolgreich verarbeitet und Lambda ruft die Funktion mit demselben Nachrichten-Batch auf.
## Überprüfen Sie die Protokolle CloudWatch
**Um zu bestätigen, dass die Event Function die Nachricht verarbeitet hat**
1. Öffnen Sie die [Seite Event Functions](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Funktion **ProcessSQSRecord** aus.
1. Wählen Sie **Überwachen** aus.
1. Wählen Sie ** CloudWatch Protokolle anzeigen** aus.
1. Wählen Sie in der CloudWatch Konsole den **Protokollstream** für die Funktion aus.
1. Suchen Sie das Protokoll `INFO`. Hier protokolliert die Lambda-Ereignisfunktion den Nachrichtentext. Sie sollten die Nachricht sehen, die Sie über die Amazon-SQS-Warteschlange gesendet haben. Beispiel:
```
2023-09-11T22:49:12.730Z b0c41e9c-0556-5a8b-af83-43e59efeec71 INFO Processed message this is a test message.
```
## Bereinigen Ihrer Ressourcen
Sie können jetzt die Ressourcen, die Sie für dieses Tutorial erstellt haben, löschen, es sei denn, Sie möchten sie behalten. Durch das Löschen von AWS Ressourcen, die Sie nicht mehr verwenden, vermeiden Sie unnötige Kosten für Ihre AWS-Konto.
**So löschen Sie die Ausführungsrolle**
1. Öffnen Sie die Seite [Roles](https://console.aws.amazon.com/iam/home#/roles) in der IAM-Konsole.
1. Wählen Sie die von Ihnen erstellte Ausführungsrolle aus.
1. Wählen Sie **Löschen** aus.
1. Geben Sie den Namen der Rolle in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus.
**Um die Lambda-Ereignisfunktion zu löschen**
1. Öffnen Sie die [Seite Event Functions](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Ereignisfunktion aus, die Sie erstellt haben.
1. Wählen Sie **Aktionen**, **Löschen** aus.
1. Geben Sie **confirm** in das Texteingabefeld ein und wählen Sie **Delete** (Löschen) aus.
**So löschen Sie die Amazon-SQS-Warteschlange**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon SQS SQS-Konsole unter [https://console.aws.amazon.com/sqs/](https://console.aws.amazon.com/sqs/).
1. Wählen Sie die Warteschlange aus, die Sie erstellt haben.
1. Wählen Sie **Löschen** aus.
1. Geben Sie **confirm** in das Texteingabefeld ein.
1. Wählen Sie **Löschen** aus.