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-Funktion, die Nachrichten aus einer Warteschlange von [Amazon Simple Queue Service (Amazon SQS)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html) verarbeitet. Die Lambda-Funktion wird 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.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sqs_tut_resources.png)
Führen Sie für dieses Tutorial die folgenden Schritte aus:
1. Erstellen Sie eine Lambda-Funktion, die Nachrichten in CloudWatch Logs schreibt.
1. Erstellen einer Amazon SQS-Warteschlange
1. Erstellen Sie eine Zuordnung von Ereignisquellen in Lambda. Die Zuordnung von Ereignisquellen liest die Amazon-SQS-Warteschlange und ruft Ihre Lambda-Funktion 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 CloudWatch Logs überwachen.
## 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 in Windows integrierte 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
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sqs_tut_steps1.png)
Eine [Ausführungsrolle](lambda-intro-execution-role.md) ist eine AWS Identity and Access Management (IAM-) Rolle, die einer Lambda-Funktion Zugriff 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 der Funktion
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sqs_tut_steps2.png)
Erstellen Sie eine Lambda-Funktion, die Ihre Amazon-SQS-Nachrichten verarbeitet. Der Funktionscode protokolliert den Hauptteil der Amazon SQS-Nachricht in CloudWatch Logs.
Dieses Tutorial verwendet die Runtime Node.js 24, 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-Funktion**
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-Funktion mithilfe des AWS CLI -Befehls [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-Funktion und die Amazon-SQS-Warteschlange müssen sich in demselben AWS-Region befinden.
```
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 der Funktion
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sqs_tut_steps3.png)
Rufen Sie Ihre Lambda-Funktion manuell mit dem `invoke` AWS CLI Befehl und einem Amazon SQS SQS-Beispielereignis auf.
**So rufen Sie die Lambda-Funktion mit einem Beispielereignis auf**
1. Speichern Sie die folgende JSON als Datei mit dem Namen `input.json`. Dieser JSON-Code simuliert ein Ereignis, das so ggf. von Amazon SQS an Ihre Lambda-Funktion gesendet wird, wobei `"body"` die tatsächliche Nachricht aus der Warteschlange 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`. Dort protokolliert die Lambda-Funktion 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
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sqs_tut_steps4.png)
Erstellen Sie eine Amazon-SQS-Warteschlange, die die Lambda-Funktion als Ereignisquelle verwenden kann. Die Lambda-Funktion und die Amazon-SQS-Warteschlange müssen sich in demselben AWS-Region befinden.
**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 ihn im nächsten Schritt, um die Warteschlange Ihrer Lambda-Funktion zuzuordnen.
## Konfigurieren der Ereignisquelle
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sqs_tut_steps5.png)
Verbinden Sie die Amazon-SQS-Warteschlange mit Ihrer Lambda-Funktion, indem Sie eine [Zuordnung von Ereignisquellen](invocation-eventsourcemapping.md) erstellen. Die Zuordnung von Ereignisquellen liest die Amazon-SQS-Warteschlange und ruft Ihre Lambda-Funktion auf, wenn eine neue Nachricht hinzugefügt wird.
Verwenden Sie den Befehl, um eine Zuordnung zwischen Ihrer Amazon SQS SQS-Warteschlange und Ihrer Lambda-Funktion zu erstellen. [create-event-source-mapping](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, um eine Liste Ihrer Ereignisquellenzuordnungen abzurufen. [list-event-source-mappings](https://awscli.amazonaws.com/v2/documentation/api/2.1.29/reference/lambda/list-event-source-mappings.html) Beispiel:
```
aws lambda list-event-source-mappings --function-name ProcessSQSRecord
```
## Senden einer Testnachricht
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sqs_tut_steps6.png)
**So senden Sie eine Amazon-SQS-Nachricht an die Lambda-Funktion**
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
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/sqs_tut_steps7.png)
**So vergewissern Sie sich, dass die Funktion die Nachricht verarbeitet hat**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die SQSRecord Funktion „**Verarbeiten**“.
1. Wählen Sie **Überwachen** aus.
1. Wählen Sie ** CloudWatch Protokolle anzeigen**.
1. Wählen Sie in der CloudWatch Konsole den **Protokollstream** für die Funktion aus.
1. Suchen Sie das Protokoll `INFO`. Dort protokolliert die Lambda-Funktion 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.
**So löschen Sie die Lambda-Funktion:**
1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.
1. Wählen Sie die Funktion 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.