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: Verwendung AWS Lambda mit Amazon Simple Notification Service
In diesem Tutorial verwenden Sie eine Lambda-Funktion in einem, AWS-Konto um ein Amazon Simple Notification Service (Amazon SNS) -Thema in einem separaten zu abonnieren. AWS-Konto Wenn Sie Nachrichten zu Ihrem Amazon SNS SNS-Thema veröffentlichen, liest Ihre Lambda-Funktion den Inhalt der Nachricht und gibt ihn in Amazon CloudWatch Logs aus. Um dieses Tutorial abzuschließen, verwenden Sie die AWS Command Line Interface ()AWS CLI.
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-sns-tutorial/sns_tut_resources.png)
Gehen Sie für dieses Tutorial wie folgt vor:
+ Erstellen Sie in **Konto A** ein Amazon-SNS-Thema.
+ Erstellen Sie in **Konto B** eine Lambda-Funktion, die Nachrichten aus dem Thema liest.
+ Erstellen Sie in **Konto B** ein Abonnement für das Thema.
+ Veröffentlichen Sie Nachrichten zum Amazon SNS SNS-Thema in **Konto A und stellen** Sie sicher, dass die Lambda-Funktion in **Konto B** sie in Logs ausgibt. CloudWatch
Anhand dieser Schritte lernen Sie, wie Sie ein Amazon-SNS-Thema konfigurieren, um eine Lambda-Funktion aufzurufen. Sie erfahren auch, wie Sie eine AWS Identity and Access Management (IAM-) Richtlinie erstellen, die einer Ressource in einer anderen die Erlaubnis erteilt AWS-Konto , Lambda aufzurufen.
In dem Tutorial werden zwei separate AWS-Konten verwendet. Die AWS CLI Befehle veranschaulichen dies anhand von zwei benannten Profilen`accountB`, die aufgerufen `accountA` und jeweils für die Verwendung mit einem anderen konfiguriert sind. AWS-Konto Informationen zur Konfiguration der AWS CLI Verwendung verschiedener Profile finden Sie unter [Einstellungen für Konfiguration und Anmeldeinformationsdatei](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) im *AWS Command Line Interface Benutzerhandbuch für Version 2.* Stellen Sie sicher, dass Sie AWS-Region für beide Profile dieselbe Standardeinstellung konfigurieren.
Wenn die AWS CLI Profile, die Sie für die beiden erstellen, unterschiedliche Namen AWS-Konten verwenden, oder wenn Sie das Standardprofil und ein benanntes Profil verwenden, ändern Sie die AWS CLI Befehle in den folgenden Schritten nach Bedarf.
## 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 eines Amazon-SNS-Themas (Konto A)
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_1.png)
**So erstellen Sie das -Thema**
+ Erstellen Sie in **Konto A** mit dem folgenden AWS CLI Befehl ein Amazon SNS SNS-Standardthema.
```
aws sns create-topic --name sns-topic-for-lambda --profile accountA
```
Die Ausgabe sollte in etwa wie folgt aussehen:
```
{
"TopicArn": "arn:aws:sns:us-west-2:123456789012:sns-topic-for-lambda"
}
```
Notieren Sie sich den Amazon-Ressourcennamen (ARN) Ihres Themas. Sie benötigen ihn im weiteren Verlauf des Tutorials, wenn Sie Ihrer Lambda-Funktion Berechtigungen zum Abonnieren des Themas hinzufügen.
## Erstellen einer Funktionsausführungsrolle (Konto B)
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_2.png)
Eine Ausführungsrolle ist eine IAM-Rolle, die einer Lambda-Funktion Zugriff AWS-Services und Ressourcen gewährt. Bevor Sie Ihre Funktion in **Konto B** erstellen, erstellen Sie eine Rolle, die der Funktion grundlegende Berechtigungen zum Schreiben von Protokollen in Logs erteilt. CloudWatch Die Berechtigungen zum Lesen aus Ihrem Amazon-SNS-Thema werden in einem späteren Schritt hinzugefügt.
**So erstellen Sie eine Ausführungsrolle**
1. Öffnen Sie in **Konto B** die Seite [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. Fügen Sie der Rolle wie folgt eine Richtlinie mit grundlegenden Berechtigungen hinzu:
1. Geben Sie im Suchfeld **Berechtigungsrichtlinien** die Zeichenfolge **AWSLambdaBasicExecutionRole** ein.
1. Wählen Sie **Weiter** aus.
1. Schließen Sie die Rollenerstellung ab:
1. Geben Sie unter **Rollendetails** im Feld **Rollenname** den Namen **lambda-sns-role** ein.
1. Wählen Sie **Rolle erstellen** aus.
## Erstellen einer Lambda-Funktion (Konto B)
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_3.png)
Erstellen Sie eine Lambda-Funktion, die Ihre Amazon-SNS-Nachrichten verarbeitet. Der Funktionscode protokolliert den Nachrichteninhalt jedes Datensatzes in Amazon 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-sns-to-lambda).
Nutzen eines SNS-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.SNSEvents;
// 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 SnsIntegration;
public class Function
{
public async Task FunctionHandler(SNSEvent evnt, ILambdaContext context)
{
foreach (var record in evnt.Records)
{
await ProcessRecordAsync(record, context);
}
context.Logger.LogInformation("done");
}
private async Task ProcessRecordAsync(SNSEvent.SNSRecord record, ILambdaContext context)
{
try
{
context.Logger.LogInformation($"Processed record {record.Sns.Message}");
// 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-sns-to-lambda).
Nutzen eines SNS-Ereignisses mit Lambda unter Verwendung von Go.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package main
import (
"context"
"fmt"
"github.com/aws/aws-lambda-go/events"
"github.com/aws/aws-lambda-go/lambda"
)
func handler(ctx context.Context, snsEvent events.SNSEvent) {
for _, record := range snsEvent.Records {
processMessage(record)
}
fmt.Println("done")
}
func processMessage(record events.SNSEventRecord) {
message := record.SNS.Message
fmt.Printf("Processed message: %s\n", message)
// TODO: Process your record here
}
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-sns-to-lambda).
Nutzen eines SNS-Ereignisses mit Lambda unter Verwendung von Java.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package example;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.SNSEvent;
import com.amazonaws.services.lambda.runtime.events.SNSEvent.SNSRecord;
import java.util.Iterator;
import java.util.List;
public class SNSEventHandler implements RequestHandler {
LambdaLogger logger;
@Override
public Boolean handleRequest(SNSEvent event, Context context) {
logger = context.getLogger();
List records = event.getRecords();
if (!records.isEmpty()) {
Iterator recordsIter = records.iterator();
while (recordsIter.hasNext()) {
processRecord(recordsIter.next());
}
}
return Boolean.TRUE;
}
public void processRecord(SNSRecord record) {
try {
String message = record.getSNS().getMessage();
logger.log("message: " + message);
} catch (Exception e) {
throw new RuntimeException(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-sns-to-lambda).
Konsumieren eines SNS-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 record of event.Records) {
await processMessageAsync(record);
}
console.info("done");
};
async function processMessageAsync(record) {
try {
const message = JSON.stringify(record.Sns.Message);
console.log(`Processed message ${message}`);
await Promise.resolve(1); //Placeholder for actual async work
} catch (err) {
console.error("An error occurred");
throw err;
}
}
```
Konsumieren eines SNS-Ereignisses mit Lambda unter Verwendung. TypeScript
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { SNSEvent, Context, SNSHandler, SNSEventRecord } from "aws-lambda";
export const functionHandler: SNSHandler = async (
event: SNSEvent,
context: Context
): Promise => {
for (const record of event.Records) {
await processMessageAsync(record);
}
console.info("done");
};
async function processMessageAsync(record: SNSEventRecord): Promise {
try {
const message: string = JSON.stringify(record.Sns.Message);
console.log(`Processed message ${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-sns-to-lambda).
Nutzen eines SNS-Ereignisses mit Lambda unter Verwendung von PHP
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
getRecords() as $record) {
$message = $record->getMessage();
// TODO: Implement your custom processing logic here
// Any exception thrown will be logged and the invocation will be marked as failed
echo "Processed Message: $message" . PHP_EOL;
}
}
}
return new Handler();
```
------
#### [ 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-sns-to-lambda).
Nutzen eines SNS-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 record in event['Records']:
process_message(record)
print("done")
def process_message(record):
try:
message = record['Sns']['Message']
print(f"Processed message {message}")
# TODO; Process your record here
except Exception as e:
print("An error occurred")
raise e
```
------
#### [ 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-sns-to-lambda).
Nutzen eines SNS-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'].map { |record| process_message(record) }
end
def process_message(record)
message = record['Sns']['Message']
puts("Processing message: #{message}")
rescue StandardError => e
puts("Error processing message: #{e}")
raise
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-sns-to-lambda).
Nutzen eines SNS-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::sns::SnsEvent;
use aws_lambda_events::sns::SnsRecord;
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
use tracing::info;
// Built with the following dependencies:
// aws_lambda_events = { version = "0.10.0", default-features = false, features = ["sns"] }
// lambda_runtime = "0.8.1"
// tokio = { version = "1", features = ["macros"] }
// tracing = { version = "0.1", features = ["log"] }
// tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }
async fn function_handler(event: LambdaEvent) -> Result<(), Error> {
for event in event.payload.records {
process_record(&event)?;
}
Ok(())
}
fn process_record(record: &SnsRecord) -> Result<(), Error> {
info!("Processing SNS Message: {}", record.sns.message);
// Implement your record handling code here.
Ok(())
}
#[tokio::main]
async fn main() -> Result<(), Error> {
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
.with_target(false)
.without_time()
.init();
run(service_fn(function_handler)).await
}
```
------
**So erstellen Sie die Funktion**
1. Erstellen Sie ein Verzeichnis für das Projekt und wechseln Sie dann zu diesem Verzeichnis.
```
mkdir sns-tutorial
cd sns-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. Führen Sie den folgenden AWS CLI Befehl aus, um Ihre Lambda-Funktion in **Konto B** zu erstellen.
```
aws lambda create-function --function-name Function-With-SNS \
--zip-file fileb://function.zip --handler index.handler --runtime nodejs24.x \
--role arn:aws:iam:::role/lambda-sns-role \
--timeout 60 --profile accountB
```
Die Ausgabe sollte in etwa wie folgt aussehen:
```
{
"FunctionName": "Function-With-SNS",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:Function-With-SNS",
"Runtime": "nodejs24.x",
"Role": "arn:aws:iam::123456789012:role/lambda_basic_role",
"Handler": "index.handler",
...
"RuntimeVersionConfig": {
"RuntimeVersionArn": "arn:aws:lambda:us-west-2::runtime:7d5f06b69c951da8a48b926ce280a9daf2e8bb1a74fc4a2672580c787d608206"
}
}
```
1. Notieren Sie sich den Amazon-Ressourcennamen (ARN) Ihrer Funktion. Sie benötigen ihn im weiteren Verlauf des Tutorials, wenn Sie Berechtigungen hinzufügen, um Amazon SNS das Aufrufen Ihrer Funktion zu ermöglichen.
## Hinzufügen von Berechtigungen zur Funktion (Konto B)
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_4.png)
Damit Amazon SNS Ihre Funktion aufrufen kann, muss die dafür notwendige Berechtigung in einer Anweisung einer [ressourcenbasierten Richtlinie](access-control-resource-based.md) erteilt werden. Sie fügen diese Anweisung mit dem AWS CLI `add-permission` Befehl hinzu.
**Erteilen der Berechtigung zum Aufrufen Ihrer Funktion durch Amazon SNS**
+ Führen Sie in **Konto B** den folgenden AWS CLI Befehl mit dem ARN für Ihr Amazon SNS SNS-Thema aus, das Sie zuvor aufgezeichnet haben.
```
aws lambda add-permission --function-name Function-With-SNS \
--source-arn arn:aws:sns:us-east-1::sns-topic-for-lambda \
--statement-id function-with-sns --action "lambda:InvokeFunction" \
--principal sns.amazonaws.com --profile accountB
```
Die Ausgabe sollte in etwa wie folgt aussehen:
```
{
"Statement": "{\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":
\"arn:aws:sns:us-east-1::sns-topic-for-lambda\"}},
\"Action\":[\"lambda:InvokeFunction\"],
\"Resource\":\"arn:aws:lambda:us-east-1::function:Function-With-SNS\",
\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"sns.amazonaws.com\"},
\"Sid\":\"function-with-sns\"}"
}
```
**Anmerkung**
Wenn das Konto mit dem Amazon SNS SNS-Thema in einem [Opt-In](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-regions.html) gehostet wird AWS-Region, müssen Sie die Region im Prinzipal angeben. Wenn Sie beispielsweise mit einem Amazon-SNS-Thema in der Region Asien-Pazifik (Hongkong) arbeiten, muss für den Prinzipal `sns.ap-east-1.amazonaws.com` anstelle von `sns.amazonaws.com` angegeben werden.
## Erteilen einer kontoübergreifenden Berechtigung für das Amazon-SNS-Abonnement (Konto A)
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_5.png)
Damit Ihre Lambda-Funktion in **Konto B** das Amazon-SNS-Thema abonnieren kann, das Sie in **Konto A** erstellt haben, müssen Sie **Konto B** die Berechtigung zum Abonnieren Ihres Themas erteilen. Sie erteilen diese Berechtigung mit dem AWS CLI `add-permission` Befehl.
**Erteilen der Berechtigung zum Abonnieren des Themas durch Konto B**
+ Führen Sie in **Konto A** den folgenden AWS CLI Befehl aus. Verwenden Sie den ARN für das Amazon-SNS-Thema, den Sie sich zuvor notiert haben.
```
aws sns add-permission --label lambda-access --aws-account-id \
--topic-arn arn:aws:sns:us-east-1::sns-topic-for-lambda \
--action-name Subscribe ListSubscriptionsByTopic --profile accountA
```
## Erstellen eines Abonnements (Konto B)
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_6.png)
In **Konto B** abonnieren Sie nun für Ihre Lambda-Funktion das Amazon-SNS-Thema, das Sie zu Beginn des Tutorials in **Konto A** erstellt haben. Wenn eine Nachricht an dieses Thema (`sns-topic-for-lambda`) gesendet wird, ruft Amazon SNS Ihre Lambda-Funktion `Function-With-SNS` in **Konto B** auf.
**Erstellen eines Abonnements**
+ Führen Sie in **Konto B** den folgenden AWS CLI Befehl aus. Verwenden Sie Ihre Standardregion, in der Sie Ihr Thema erstellt haben, und die ARNs für Ihr Thema und die Lambda-Funktion.
```
aws sns subscribe --protocol lambda \
--region us-east-1 \
--topic-arn arn:aws:sns:us-east-1::sns-topic-for-lambda \
--notification-endpoint arn:aws:lambda:us-east-1::function:Function-With-SNS \
--profile accountB
```
Die Ausgabe sollte in etwa wie folgt aussehen:
```
{
"SubscriptionArn": "arn:aws:sns:us-east-1::sns-topic-for-lambda:5d906xxxx-7c8x-45dx-a9dx-0484e31c98xx"
}
```
## Veröffentlichen von Nachrichten für das Thema (Konto A und Konto B)
![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_7.png)
Ihre Lambda-Funktion in **Konto B** hat nun Ihr Amazon-SNS-Thema in **Konto A** abonniert und Sie können Ihr Setup testen, indem Sie Nachrichten für das Thema veröffentlichen. Um zu bestätigen, dass Amazon SNS Ihre Lambda-Funktion aufgerufen hat, verwenden Sie CloudWatch Logs, um die Ausgabe Ihrer Funktion anzusehen.
**Veröffentlichen einer Nachricht für Ihr Thema und Anzeigen der Ausgabe Ihrer Funktion**
1. Geben Sie `Hello World` in eine Textdatei ein und speichern Sie sie als `message.txt`.
1. **Führen Sie aus demselben Verzeichnis, in dem Sie Ihre Textdatei gespeichert haben, den folgenden AWS CLI Befehl in Konto A aus.** Verwenden Sie den ARN für Ihr eigenes Thema.
```
aws sns publish --message file://message.txt --subject Test \
--topic-arn arn:aws:sns:us-east-1::sns-topic-for-lambda \
--profile accountA
```
Dadurch wird eine eindeutige Nachrichten-ID zurückgegeben, die angibt, dass Amazon SNS die Nachricht akzeptiert hat. Anschließend versucht Amazon SNS, die Nachricht den Abonnenten des Themas zuzustellen. Um zu bestätigen, dass Amazon SNS Ihre Lambda-Funktion aufgerufen hat, verwenden Sie CloudWatch Logs, um die Ausgabe Ihrer Funktion einzusehen:
1. Öffnen Sie in **Konto B** die Seite [Protokollgruppen](https://console.aws.amazon.com/cloudwatch/home#logsV2:log-groups) der CloudWatch Amazon-Konsole.
1. Wählen Sie die Protokollgruppe für Ihre Funktion (`/aws/lambda/Function-With-SNS`) aus.
1. Wählen Sie den neuesten Protokollstreams aus.
1. Wenn Ihre Funktion korrekt aufgerufen wurde, sieht die Ausgabe in etwa wie folgt aus und enthält die Inhalte der Nachricht, die Sie für Ihr Thema veröffentlicht haben.
```
2023-07-31T21:42:51.250Z c1cba6b8-ade9-4380-aa32-d1a225da0e48 INFO Processed message Hello World
2023-07-31T21:42:51.250Z c1cba6b8-ade9-4380-aa32-d1a225da0e48 INFO done
```
## 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.
Bereinigen Sie über **Konto A** Ihr Amazon-SNS-Thema.
**So löschen Sie das Amazon-SNS-Thema**
1. Öffnen Sie die Seite [Themen](https://console.aws.amazon.com//sns/home#topics:) der Amazon-SNS-Konsole.
1. Wählen Sie das Thema aus, das Sie gerade erstellt haben.
1. Wählen Sie **Löschen** aus.
1. Geben Sie **delete me** in das Texteingabefeld ein.
1. Wählen Sie **Löschen** aus.
Bereinigen Sie über **Konto B** Ihre Ausführungsrolle, die Lambda-Funktion und das Amazon-SNS-Abonnement.
**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 das Amazon-SNS-Abonnement**
1. Öffnen Sie die Seite [Abonnements](https://console.aws.amazon.com//sns/home#subscriptions:) der Amazon-SNS-Konsole.
1. Wählen Sie das von Ihnen erstellte Abonnement aus.
1. Wählen Sie **Löschen**, **Löschen** aus.