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.

# Erstellen Sie ein Amazon SNS-Thema
<a name="sns-create-topic"></a>

Ein Amazon SNS-Thema ist ein logischer Zugriffspunkt, der als ein *Kommunikationskanal* fungiert. Mit einem Thema können Sie mehrere *Endpunkte* gruppieren (z. B. AWS Lambda Amazon SQS, HTTP/S oder eine E-Mail-Adresse).

Zum Senden der Nachrichten eines Nachrichtenproduktionssystems (etwa einer e-Commerce-Website), die mit mehreren anderen Services zusammenarbeiten, die dessen Nachrichten benötigen (beispielsweise Checkout- und Erfüllungssysteme) können Sie ein Thema für Ihr Produktionssystem erstellen.

Die erste und häufigste Amazon SNS-Aufgabe ist das Erstellen eines Themas. Auf dieser Seite wird gezeigt AWS-Managementkonsole, wie Sie die, und die verwenden können AWS SDK für Java, um ein Thema AWS SDK für .NET zu erstellen.

Während der Erstellung wählen Sie einen Thementyp (Standard oder FIFO) und benennen das Thema. Der Thementyp oder -name kann nach dem Erstellen eines Themas nicht geändert werden. Alle anderen Konfigurationsoptionen sind während der Themenerstellung optional und Sie können sie später bearbeiten.

**Wichtig**  
Fügen Sie keine persönlich identifizierbare Informationen (PII) oder andere vertrauliche oder sensible Informationen in Themennamen hinzu. Themennamen sind für andere Amazon Web Services zugänglich, einschließlich CloudWatch Logs. Themennamen sind nicht für private oder sensible Daten gedacht.

## Um ein Thema mit dem zu erstellen AWS-Managementkonsole
<a name="create-topic-aws-console"></a>

Durch die Erstellung eines Themas in Amazon SNS wird die Grundlage für die Nachrichtenverteilung geschaffen, sodass Sie Nachrichten veröffentlichen können, die an mehrere Abonnenten verteilt werden können. Dieser Schritt ist wichtig, um den Typ, die Verschlüsselungseinstellungen und die Zugriffsrichtlinien des Themas zu konfigurieren und sicherzustellen, dass das Thema den Sicherheits-, Compliance- und Betriebsanforderungen des Unternehmens entspricht.

1. Melden Sie sich bei der [Amazon-SNS-Konsole](https://console.aws.amazon.com/sns/home) an.

1. Führen Sie eine der folgenden Aktionen aus:
   + Wenn noch nie zuvor Themen unter Ihrem AWS-Konto Konto erstellt wurden, lesen Sie die Beschreibung von Amazon SNS auf der Startseite.
   + Wenn AWS-Konto zuvor Themen unter Ihrem Konto erstellt wurden, wählen Sie im Navigationsbereich die Option **Themen** aus.

1. Klicken Sie auf der Seite **Themen** auf **Create New Topic**.

1. Führen Sie auf der Seite **Create subscription (Abonnement erstellen)** im Abschnitt **Details** die folgenden Schritte aus:

   1. Für**Typ**Wählen Sie einen Thementyp aus (**Standard-**oder**FIFO**).

   1. Geben Sie den **Namen** des neuen Themas ein. Für eine[FIFO-Thema](sns-fifo-topics.md)Fügen Sie**FIFO**am Ende des Namens hinzu.

   1. (Optional) Geben Sie einen **Display name** (Anzeigenamen) für Ihr Thema ein.
**Wichtig**  
Wenn Sie einen E-Mail-Endpunkt abonnieren, darf die kombinierte Zeichenanzahl für den Anzeigenamen des Amazon-SNS-Themas und die sendende E-Mail-Adresse (z. B. no-reply@sns.amazonaws.com) 320 UTF-8-Zeichen nicht überschreiten. Sie können ein Verschlüsselungstool eines Drittanbieters verwenden, um die Länge der Absenderadresse zu überprüfen, bevor Sie einen Anzeigenamen für Ihr Amazon-SNS-Thema konfigurieren.
**Anmerkung**  
Bei E-Mail- und E-Mail-JSON-Abonnements wird der Anzeigename des Themas nur für reguläre Benachrichtigungen als Absendername verwendet. E-Mails zur Bestätigung von Abonnements und zur Bestätigung der Abmeldung verwenden immer „AWS Benachrichtigungen“ als Absendername, unabhängig von der Einstellung für den Anzeigenamen des Themas.

   1. (Optional) Für ein FIFO-Thema können Sie**Deduplizierung für inhaltsbasierte Nachrichten**, um die Standardnachrichtendeduplizierung zu aktivieren. Weitere Informationen finden Sie unter [Amazon SNS SNS-Nachrichtendeduplizierung für FIFO-Themen](fifo-message-dedup.md).

1. (Optional) Erweitern Sie den Abschnitt **Encryption (Verschlüsselung)** und gehen Sie wie folgt vor. Weitere Informationen finden Sie unter [Sicherung von Amazon SNS SNS-Daten mit serverseitiger Verschlüsselung](sns-server-side-encryption.md).

   1. Wählen Sie **Enable encryption (Verschlüsselung aktivieren)** aus.

   1. Geben Sie den AWS KMS Schlüssel an. Weitere Informationen finden Sie unter [Wichtige Begriffe](sns-server-side-encryption.md#sse-key-terms).

      Für jeden KMS-Typ werden **Description** (Beschreibung), **Account** (Konto) und **KMS ARN (KMS-ARN)** angezeigt.
**Wichtig**  
Wenn Sie nicht der Besitzer des KMS-Schlüssels sind oder wenn Sie sich mit einem Konto anmelden, das über keine `kms:ListAliases`- und `kms:DescribeKey`-Berechtigungen verfügt, können Sie auf der Amazon-SNS-Konsole keine Informationen über den KMS aufrufen.  
Bitten Sie den Inhaber des KMS, Ihnen diese Berechtigungen zu erteilen. Beispiele und weitere Informationen zu [AWS KMS -Berechtigungen finden Sie unter ](https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html) API-Berechtigungen: Referenztabelle für Aktionen und Ressourcen im *AWS Key Management Service Benutzerhandbuch*.
      + Das AWS verwaltete KMS für Amazon SNS **(Standard) alias/aws/sns** ist standardmäßig ausgewählt.
**Anmerkung**  
Beachten Sie Folgendes:  
Wenn Sie das erste Mal verwenden AWS-Managementkonsole , um das AWS verwaltete KMS für Amazon SNS für ein Thema anzugeben, AWS KMS wird das AWS verwaltete KMS für Amazon SNS erstellt.
Alternativ können Sie, wenn Sie die `Publish` Aktion zum ersten Mal für ein Thema mit aktivierter SSE verwenden, das AWS KMS AWS verwaltete KMS für Amazon SNS erstellen.
      + Um ein benutzerdefiniertes KMS von Ihrem AWS Konto aus zu verwenden, wählen Sie das **KMS-Schlüsselfeld** und dann das benutzerdefinierte KMS aus der Liste aus.
**Anmerkung**  
Anweisungen zur Erstellung benutzerdefinierter KMSs Schlüssel finden Sie unter [Creating Keys](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) im *AWS Key Management Service Developer Guide*
      + Um einen benutzerdefinierten KMS-ARN von Ihrem AWS Konto oder einem anderen AWS Konto zu verwenden, geben Sie ihn in das Feld **KMS-Schlüssel** ein.

1. (Optional) Standardmäßig kann nur der Eigentümer des Themas das Thema abonnieren oder Veröffentlichungen dazu vornehmen. Um zusätzliche Zugriffsberechtigungen zu konfigurieren, erweitern Sie den Abschnitt **Access policy (Zugriffsrichtlinie)**. Weitere Informationen erhalten Sie unter [Identity and Access Management in Amazon SNS](security-iam.md) und [Beispiele für die Zugriffskontrolle in Amazon SNS](sns-access-policy-use-cases.md). 
**Anmerkung**  
Wenn Sie ein Thema mit der Konsole erstellen, verwendet die Standardrichtlinie den Bedingungsschlüssel `aws:SourceOwner`. Dieser Schlüssel ist ähnlich wie `aws:SourceAccount`. 

1. (Optional) Um zu konfigurieren, wie Amazon SNS fehlgeschlagene Nachrichtenzustellversuche wiederholt, erweitern Sie den Abschnitt **Delivery retry policy (HTTP/S)** (Richtlinie für die Zustellungswiederholung (HTTP/S)). Weitere Informationen finden Sie unter [Wiederholungsversuche bei der Nachrichtenzustellung Amazon SNS](sns-message-delivery-retries.md).

1. (Optional) Um zu konfigurieren, wie Amazon SNS die Zustellung von Nachrichten protokolliert CloudWatch, erweitern Sie den Abschnitt **Protokollierung des Lieferstatus**. Weitere Informationen finden Sie unter [Zustellungsstatus von Amazon SNS Nachrichtenübermittmittungen](sns-topic-attributes.md).

1. (Optional) Wenn Sie Metadaten-Tags zum Thema hinzufügen, erweitern Sie den **Tag**-Abschnitt, geben Sie einen **Schlüssel** und einen **Wert** ein (optional), und wählen Sie **Tag hinzufügen** aus. Weitere Informationen finden Sie unter [Markierung von Amazon-SNS-Themen](sns-tags.md).

1. Wählen Sie **Thema erstellen** aus.

   Das Thema wird erstellt und die **{{MyTopic}}**Seite wird angezeigt.

   Der **Name**, der **ARN**, (optional) der **Anzeigename** und die AWS Konto-ID des **Themenbesitzers** werden im Abschnitt **Details** angezeigt.

1. Kopieren Sie das Thema ARN in die Zwischenablage, zum Beispiel:

   ```
   arn:aws:sns:us-east-2:123456789012:MyTopic
   ```

## Um ein Thema mit einem AWS SDK zu erstellen
<a name="create-topic-aws-sdks"></a>

Um ein AWS SDK verwenden zu können, müssen Sie es mit Ihren Anmeldeinformationen konfigurieren. Weitere Informationen finden Sie unter [Die Dateien für die gemeinsame Konfiguration und die Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) im *AWS SDKs Referenzhandbuch zu Tools*.

Die folgenden Code-Beispiele zeigen, wie `CreateTopic` verwendet wird.

------
#### [ .NET ]

**SDK für .NET**  
 Weitere Informationen finden Sie unter GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SNS#code-examples) einrichten und ausführen. 
Erstellen Sie ein Thema mit einem bestimmten Namen.  

```
    using System;
    using System.Threading.Tasks;
    using Amazon.SimpleNotificationService;
    using Amazon.SimpleNotificationService.Model;

    /// <summary>
    /// This example shows how to use Amazon Simple Notification Service
    /// (Amazon SNS) to add a new Amazon SNS topic.
    /// </summary>
    public class CreateSNSTopic
    {
        public static async Task Main()
        {
            string topicName = "ExampleSNSTopic";

            IAmazonSimpleNotificationService client = new AmazonSimpleNotificationServiceClient();

            var topicArn = await CreateSNSTopicAsync(client, topicName);
            Console.WriteLine($"New topic ARN: {topicArn}");
        }

        /// <summary>
        /// Creates a new SNS topic using the supplied topic name.
        /// </summary>
        /// <param name="client">The initialized SNS client object used to
        /// create the new topic.</param>
        /// <param name="topicName">A string representing the topic name.</param>
        /// <returns>The Amazon Resource Name (ARN) of the created topic.</returns>
        public static async Task<string> CreateSNSTopicAsync(IAmazonSimpleNotificationService client, string topicName)
        {
            var request = new CreateTopicRequest
            {
                Name = topicName,
            };

            var response = await client.CreateTopicAsync(request);

            return response.TopicArn;
        }
    }
```
Erstellen Sie ein neues Thema mit einem Namen und spezifischen FIFO- und Deduplizierungsattributen.  

```
    /// <summary>
    /// Create a new topic with a name and specific FIFO and de-duplication attributes.
    /// </summary>
    /// <param name="topicName">The name for the topic.</param>
    /// <param name="useFifoTopic">True to use a FIFO topic.</param>
    /// <param name="useContentBasedDeduplication">True to use content-based de-duplication.</param>
    /// <returns>The ARN of the new topic.</returns>
    public async Task<string> CreateTopicWithName(string topicName, bool useFifoTopic, bool useContentBasedDeduplication)
    {
        var createTopicRequest = new CreateTopicRequest()
        {
            Name = topicName,
        };

        if (useFifoTopic)
        {
            // Update the name if it is not correct for a FIFO topic.
            if (!topicName.EndsWith(".fifo"))
            {
                createTopicRequest.Name = topicName + ".fifo";
            }

            // Add the attributes from the method parameters.
            createTopicRequest.Attributes = new Dictionary<string, string>
            {
                { "FifoTopic", "true" }
            };
            if (useContentBasedDeduplication)
            {
                createTopicRequest.Attributes.Add("ContentBasedDeduplication", "true");
            }
        }

        var createResponse = await _amazonSNSClient.CreateTopicAsync(createTopicRequest);
        return createResponse.TopicArn;
    }
```
+  Einzelheiten zur API finden Sie [CreateTopic](https://docs.aws.amazon.com/goto/DotNetSDKV3/sns-2010-03-31/CreateTopic)in der *AWS SDK für .NET API-Referenz*. 

------
#### [ C\+\+ ]

**SDK für C\+\+**  
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sns#code-examples) einrichten und ausführen. 

```
//! Create an Amazon Simple Notification Service (Amazon SNS) topic.
/*!
  \param topicName: An Amazon SNS topic name.
  \param topicARNResult: String to return the Amazon Resource Name (ARN) for the topic.
  \param clientConfiguration: AWS client configuration.
  \return bool: Function succeeded.
 */
bool AwsDoc::SNS::createTopic(const Aws::String &topicName,
                              Aws::String &topicARNResult,
                              const Aws::Client::ClientConfiguration &clientConfiguration) {
    Aws::SNS::SNSClient snsClient(clientConfiguration);

    Aws::SNS::Model::CreateTopicRequest request;
    request.SetName(topicName);

    const Aws::SNS::Model::CreateTopicOutcome outcome = snsClient.CreateTopic(request);

    if (outcome.IsSuccess()) {
        topicARNResult = outcome.GetResult().GetTopicArn();
        std::cout << "Successfully created an Amazon SNS topic " << topicName
                  << " with topic ARN '" << topicARNResult
                  << "'." << std::endl;

    }
    else {
        std::cerr << "Error creating topic " << topicName << ":" <<
                  outcome.GetError().GetMessage() << std::endl;
        topicARNResult.clear();
    }

    return outcome.IsSuccess();
}
```
+  Einzelheiten zur API finden Sie [CreateTopic](https://docs.aws.amazon.com/goto/SdkForCpp/sns-2010-03-31/CreateTopic)in der *AWS SDK für C\+\+ API-Referenz*. 

------
#### [ CLI ]

**AWS CLI**  
**So erstellen Sie ein SNS-Thema**  
Das folgende `create-topic`-Beispiel erstellt ein SNS-Thema namens `my-topic`.  

```
aws sns create-topic \
    --name {{my-topic}}
```
Ausgabe:  

```
{
    "ResponseMetadata": {
        "RequestId": "1469e8d7-1642-564e-b85d-a19b4b341f83"
    },
    "TopicArn": "arn:aws:sns:us-west-2:123456789012:my-topic"
}
```
Weitere Informationen finden Sie unter [Verwenden der AWS Befehlszeilenschnittstelle mit Amazon SQS und Amazon SNS](https://docs.aws.amazon.com/cli/latest/userguide/cli-sqs-queue-sns-topic.html) im *Benutzerhandbuch für die AWS Befehlszeilenschnittstelle*.  
+  Einzelheiten zur API finden Sie unter [CreateTopic AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/create-topic.html)*Befehlsreferenz*. 

------
#### [ Go ]

**SDK für Go V2**  
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/workflows/topics_and_queues#code-examples) einrichten und ausführen. 

```
import (
	"context"
	"encoding/json"
	"log"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/sns"
	"github.com/aws/aws-sdk-go-v2/service/sns/types"
)

// SnsActions encapsulates the Amazon Simple Notification Service (Amazon SNS) actions
// used in the examples.
type SnsActions struct {
	SnsClient *sns.Client
}



// CreateTopic creates an Amazon SNS topic with the specified name. You can optionally
// specify that the topic is created as a FIFO topic and whether it uses content-based
// deduplication instead of ID-based deduplication.
func (actor SnsActions) CreateTopic(ctx context.Context, topicName string, isFifoTopic bool, contentBasedDeduplication bool) (string, error) {
	var topicArn string
	topicAttributes := map[string]string{}
	if isFifoTopic {
		topicAttributes["FifoTopic"] = "true"
	}
	if contentBasedDeduplication {
		topicAttributes["ContentBasedDeduplication"] = "true"
	}
	topic, err := actor.SnsClient.CreateTopic(ctx, &sns.CreateTopicInput{
		Name:       aws.String(topicName),
		Attributes: topicAttributes,
	})
	if err != nil {
		log.Printf("Couldn't create topic %v. Here's why: %v\n", topicName, err)
	} else {
		topicArn = *topic.TopicArn
	}

	return topicArn, err
}
```
+  Einzelheiten zur API finden Sie [CreateTopic](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sns#Client.CreateTopic)in der *AWS SDK für Go API-Referenz*. 

------
#### [ Java ]

**SDK für Java 2.x**  
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/sns#code-examples) einrichten und ausführen. 

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.CreateTopicRequest;
import software.amazon.awssdk.services.sns.model.CreateTopicResponse;
import software.amazon.awssdk.services.sns.model.SnsException;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class CreateTopic {
    public static void main(String[] args) {
        final String usage = """

                Usage:    <topicName>

                Where:
                   topicName - The name of the topic to create (for example, mytopic).

                """;

        if (args.length != 1) {
            System.out.println(usage);
            System.exit(1);
        }

        String topicName = args[0];
        System.out.println("Creating a topic with name: " + topicName);
        SnsClient snsClient = SnsClient.builder()
                .region(Region.US_EAST_1)
                .build();

        String arnVal = createSNSTopic(snsClient, topicName);
        System.out.println("The topic ARN is" + arnVal);
        snsClient.close();
    }

    public static String createSNSTopic(SnsClient snsClient, String topicName) {
        CreateTopicResponse result;
        try {
            CreateTopicRequest request = CreateTopicRequest.builder()
                    .name(topicName)
                    .build();

            result = snsClient.createTopic(request);
            return result.topicArn();

        } catch (SnsException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }
}
```
+  Einzelheiten zur API finden Sie [CreateTopic](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/CreateTopic)in der *AWS SDK for Java 2.x API-Referenz*. 

------
#### [ JavaScript ]

**SDK für JavaScript (v3)**  
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples) einrichten und ausführen. 
Erstellen Sie den Client in einem separaten Modul und exportieren Sie ihn.  

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```
Importieren Sie das SDK- und Client-Module und rufen Sie die API auf.  

```
import { CreateTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicName - The name of the topic to create.
 */
export const createTopic = async (topicName = "TOPIC_NAME") => {
  const response = await snsClient.send(
    new CreateTopicCommand({ Name: topicName }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '087b8ad2-4593-50c4-a496-d7e90b82cf3e',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:TOPIC_NAME'
  // }
  return response;
};
```
+  Weitere Informationen finden Sie im [AWS SDK für JavaScript -Entwicklerhandbuch](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topics-createtopic). 
+  Einzelheiten zur API finden Sie [CreateTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/CreateTopicCommand)in der *AWS SDK für JavaScript API-Referenz*. 

------
#### [ Kotlin ]

**SDK für Kotlin**  
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/sns#code-examples) einrichten und ausführen. 

```
suspend fun createSNSTopic(topicName: String): String {
    val request =
        CreateTopicRequest {
            name = topicName
        }

    SnsClient.fromEnvironment { region = "us-east-1" }.use { snsClient ->
        val result = snsClient.createTopic(request)
        return result.topicArn.toString()
    }
}
```
+  Einzelheiten zur API finden Sie [CreateTopic](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*. 

------
#### [ PHP ]

**SDK für PHP**  
 Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/sns#code-examples) einrichten und ausführen. 

```
require 'vendor/autoload.php';

use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;


/**
 * Create a Simple Notification Service topics in your AWS account at the requested region.
 *
 * This code expects that you have AWS credentials set up per:
 * https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
 */

$SnSclient = new SnsClient([
    'profile' => 'default',
    'region' => 'us-east-1',
    'version' => '2010-03-31'
]);

$topicname = 'myTopic';

try {
    $result = $SnSclient->createTopic([
        'Name' => $topicname,
    ]);
    var_dump($result);
} catch (AwsException $e) {
    // output error message if fails
    error_log($e->getMessage());
}
```
+  Weitere Informationen finden Sie im [AWS SDK für PHP -Entwicklerhandbuch](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-managing-topics.html#create-a-topic). 
+  Einzelheiten zur API finden Sie [CreateTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/CreateTopic)in der *AWS SDK für PHP API-Referenz*. 

------
#### [ Python ]

**SDK für Python (Boto3)**  
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/sns#code-examples) einrichten und ausführen. 

```
class SnsWrapper:
    """Encapsulates Amazon SNS topic and subscription functions."""

    def __init__(self, sns_resource):
        """
        :param sns_resource: A Boto3 Amazon SNS resource.
        """
        self.sns_resource = sns_resource


    def create_topic(self, name):
        """
        Creates a notification topic.

        :param name: The name of the topic to create.
        :return: The newly created topic.
        """
        try:
            topic = self.sns_resource.create_topic(Name=name)
            logger.info("Created topic %s with ARN %s.", name, topic.arn)
        except ClientError:
            logger.exception("Couldn't create topic %s.", name)
            raise
        else:
            return topic
```

```
class SnsWrapper:
    """Wrapper class for managing Amazon SNS operations."""

    def __init__(self, sns_client: Any) -> None:
        """
        Initialize the SnsWrapper.

        :param sns_client: A Boto3 Amazon SNS client.
        """
        self.sns_client = sns_client

    @classmethod
    def from_client(cls) -> 'SnsWrapper':
        """
        Create an SnsWrapper instance using a default boto3 client.

        :return: An instance of this class.
        """
        sns_client = boto3.client('sns')
        return cls(sns_client)


    def create_topic(
        self, 
        topic_name: str, 
        is_fifo: bool = False, 
        content_based_deduplication: bool = False
    ) -> str:
        """
        Create an SNS topic.

        :param topic_name: The name of the topic to create.
        :param is_fifo: Whether to create a FIFO topic.
        :param content_based_deduplication: Whether to use content-based deduplication for FIFO topics.
        :return: The ARN of the created topic.
        :raises ClientError: If the topic creation fails.
        """
        try:
            # Add .fifo suffix for FIFO topics
            if is_fifo and not topic_name.endswith('.fifo'):
                topic_name += '.fifo'

            attributes = {}
            if is_fifo:
                attributes['FifoTopic'] = 'true'
                if content_based_deduplication:
                    attributes['ContentBasedDeduplication'] = 'true'

            response = self.sns_client.create_topic(
                Name=topic_name,
                Attributes=attributes
            )

            topic_arn = response['TopicArn']
            logger.info(f"Created topic: {topic_name} with ARN: {topic_arn}")
            return topic_arn

        except ClientError as e:
            error_code = e.response.get('Error', {}).get('Code', 'Unknown')
            logger.error(f"Error creating topic {topic_name}: {error_code} - {e}")
            raise
```
+  Einzelheiten zur API finden Sie [CreateTopic](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/CreateTopic)in *AWS SDK for Python (Boto3) API* Reference. 

------
#### [ Ruby ]

**SDK für Ruby**  
 Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/sns#code-examples) einrichten und ausführen. 

```
# This class demonstrates how to create an Amazon Simple Notification Service (SNS) topic.
class SNSTopicCreator
  # Initializes an SNS client.
  #
  # Utilizes the default AWS configuration for region and credentials.
  def initialize
    @sns_client = Aws::SNS::Client.new
  end

  # Attempts to create an SNS topic with the specified name.
  #
  # @param topic_name [String] The name of the SNS topic to create.
  # @return [Boolean] true if the topic was successfully created, false otherwise.
  def create_topic(topic_name)
    @sns_client.create_topic(name: topic_name)
    puts "The topic '#{topic_name}' was successfully created."
    true
  rescue Aws::SNS::Errors::ServiceError => e
    # Handles SNS service errors gracefully.
    puts "Error while creating the topic named '#{topic_name}': #{e.message}"
    false
  end
end

# Example usage:
if $PROGRAM_NAME == __FILE__
  topic_name = 'YourTopicName' # Replace with your topic name
  sns_topic_creator = SNSTopicCreator.new

  puts "Creating the topic '#{topic_name}'..."
  unless sns_topic_creator.create_topic(topic_name)
    puts 'The topic was not created. Stopping program.'
    exit 1
  end
end
```
+  Weitere Informationen finden Sie im [AWS SDK für Ruby -Entwicklerhandbuch](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/sns-example-create-topic.html). 
+  Einzelheiten zur API finden Sie [CreateTopic](https://docs.aws.amazon.com/goto/SdkForRubyV3/sns-2010-03-31/CreateTopic)in der *AWS SDK für Ruby API-Referenz*. 

------
#### [ Rust ]

**SDK für Rust**  
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/sns#code-examples) einrichten und ausführen. 

```
async fn make_topic(client: &Client, topic_name: &str) -> Result<(), Error> {
    let resp = client.create_topic().name(topic_name).send().await?;

    println!(
        "Created topic with ARN: {}",
        resp.topic_arn().unwrap_or_default()
    );

    Ok(())
}
```
+  Einzelheiten zur API finden Sie [CreateTopic](https://docs.rs/aws-sdk-sns/latest/aws_sdk_sns/client/struct.Client.html#method.create_topic)in der *API-Referenz zum AWS SDK für Rust*. 

------
#### [ SAP ABAP ]

**SDK für SAP ABAP**  
 Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/sns#code-examples) einrichten und ausführen. 

```
    TRY.
        oo_result = lo_sns->createtopic( iv_name = iv_topic_name ). " oo_result is returned for testing purposes. "
        MESSAGE 'SNS topic created' TYPE 'I'.
      CATCH /aws1/cx_snstopiclimitexcdex.
        MESSAGE 'Unable to create more topics. You have reached the maximum number of topics allowed.' TYPE 'E'.
    ENDTRY.
```
+  Einzelheiten zur API finden Sie [CreateTopic](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)in der *API-Referenz zum AWS SDK für SAP ABAP*. 

------
#### [ Swift ]

**SDK für Swift**  
 Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/sns#code-examples) einrichten und ausführen. 

```
import AWSSNS

        let config = try await SNSClient.SNSClientConfiguration(region: region)
        let snsClient = SNSClient(config: config)

        let output = try await snsClient.createTopic(
            input: CreateTopicInput(name: name)
        )

        guard let arn = output.topicArn else {
            print("No topic ARN returned by Amazon SNS.")
            return
        }
```
+  Einzelheiten zur API finden Sie [CreateTopic](https://sdk.amazonaws.com/swift/api/awssns/latest/documentation/awssns/snsclient/createtopic(input:))in der *API-Referenz zum AWS SDK für Swift*. 

------