As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Criar um tópico do Amazon SNS
<a name="sns-create-topic"></a>

Um tópico do Amazon SNS é um ponto de acesso lógico que atua como um *canal de comunicação*. Um tópico permite agrupar vários *endpoints* (como Amazon SQS AWS Lambda, HTTP/S ou um endereço de e-mail).

Para transmitir as mensagens de um sistema produtor de mensagem (por exemplo, um site de comércio eletrônico) que trabalha com vários outros serviços que exigem suas mensagens (por exemplo, sistemas de cumprimento e checkout), crie um tópico para o sistema produtor.

A tarefa inicial e mais comum do Amazon SNS é a criação de um tópico. Esta página mostra como você pode usar o Console de gerenciamento da AWS AWS SDK para Java, o e o AWS SDK para .NET para criar um tópico.

Durante a criação, você escolhe um tipo de tópico (padrão ou FIFO) e nomeia o tópico. Depois de criado um tópico, você não pode alterar o tipo ou o nome do tópico. Todas as outras opções de configuração são opcionais durante a criação do tópico e você pode editá-las posteriormente.

**Importante**  
Não inclua informações de identificação pessoal (PII) nem outras informações confidenciais ou sigilosas em nomes de tópicos. Os nomes dos tópicos podem ser acessados por outros Amazon Web Services, incluindo CloudWatch Logs. Os nomes de tópicos não devem ser usados para dados privados ou sigilosos.

## Para criar um tópico usando o Console de gerenciamento da AWS
<a name="create-topic-aws-console"></a>

A criação de um tópico no Amazon SNS estabelece a base para a distribuição de mensagens, permitindo que você publique mensagens que podem ser distribuídas para vários assinantes. Essa etapa é essencial para definir o tipo, as configurações de criptografia e as políticas de acesso do tópico, garantindo que o tópico atenda aos requisitos operacionais, de segurança e de conformidade da organização.

1. Faça login no console [do Amazon SNS](https://console.aws.amazon.com/sns/home).

1. Execute um destes procedimentos:
   + Se nenhum tópico já tiver sido criado Conta da AWS antes, leia a descrição do Amazon SNS na página inicial.
   + Se os tópicos já tiverem sido criados abaixo Conta da AWS do seu, no painel de navegação, escolha **Tópicos**.

1. Na página **Tópicos**, escolha **Criar tópico**.

1. Na página **Criar tópico**, na seção **Detalhes**, faça o seguinte:

   1. Em **Tipo**, escolha um tipo de tópico (**Standard** ou **FIFO**).

   1. Insira um **Nome** para o tópico. Para um [tópico FIFO](sns-fifo-topics.md), adicione **.fifo** ao final do nome.

   1. (Opcional) Insira um **Nome de exibição** para o tópico.
**Importante**  
Ao assinar um endpoint de e-mail, a contagem combinada de caracteres para o nome de exibição do tópico do Amazon SNS e o endereço de e-mail do remetente (por exemplo, no-reply@sns.amazonaws.com) não deve exceder 320 caracteres UTF-8. Você pode usar uma ferramenta de codificação de terceiros para verificar o tamanho do endereço de remetente antes de configurar um nome de exibição para seu tópico do Amazon SNS.

   1. (Opcional) Para um tópico FIFO, você pode escolher **Desduplicação de mensagens baseada em conteúdo** para habilitar a desduplicação de mensagens padrão. Para obter mais informações, consulte [Desduplicação de mensagens do Amazon SNS para tópicos FIFO](fifo-message-dedup.md).

1. (Opcional) Expanda a seção **Criptografia** e faça o seguinte. Para obter mais informações, consulte [Segurança dos dados do Amazon SNS com a criptografia do lado do servidor](sns-server-side-encryption.md).

   1. Selecione **Habilitar criptografia**.

   1. Especifique a AWS KMS chave. Para obter mais informações, consulte [Principais termos](sns-server-side-encryption.md#sse-key-terms).

      Para cada tipo de KMS, são exibidos **Description** (Descrição), **Account** (Conta) e **KMS ARN** (ARN do KMS).
**Importante**  
Se você não for o proprietário do KMS ou se fizer login com uma conta que não tenha as permissões `kms:ListAliases` e `kms:DescribeKey`, não será possível visualizar as informações sobre o KMS no console do Amazon SNS.  
Peça ao proprietário do KMS para conceder essas permissões a você. Para obter mais informações, consulte [Permissões da API do KMS: referência de ações e recursos do AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html) no *Guia do desenvolvedor do AWS Key Management Service *.
      + O KMS AWS gerenciado para Amazon **SNS (padrão alias/aws/sns**) é selecionado por padrão.
**nota**  
Lembre-se do seguinte:  
A primeira vez que você usa o Console de gerenciamento da AWS para especificar o KMS AWS gerenciado para o Amazon SNS para um tópico AWS KMS , cria AWS o KMS gerenciado para o Amazon SNS.
Como alternativa, na primeira vez que você usa a `Publish` ação em um tópico com o SSE ativado, AWS KMS cria o KMS AWS gerenciado para o Amazon SNS.
      + Para usar um KMS personalizado da sua AWS conta, escolha o campo **Chave KMS** e, em seguida, escolha o KMS personalizado na lista.
**nota**  
Para obter instruções sobre como criar chaves personalizadas KMSs, consulte [Criação de chaves](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) no *Guia do AWS Key Management Service desenvolvedor*
      + Para usar um ARN KMS personalizado da AWS sua conta ou de AWS outra conta, insira-o no campo Chave **do KMS**.

1. (Opcional) Por padrão, somente o proprietário do tópico pode publicar ou assinar o tópico. Para configurar permissões de acesso adicionais, expanda a seção **Política de acesso**. Para obter mais informações, consulte [Gerenciamento de identidade e acesso no Amazon SNS](security-iam.md) e [Casos de exemplo para controle de acesso do Amazon SNS](sns-access-policy-use-cases.md). 
**nota**  
Quando você cria um tópico usando o console, a política padrão usa a chave de condição `aws:SourceOwner`. Essa chave é semelhante a `aws:SourceAccount`. 

1. (Opcional) Para configurar como o Amazon SNS repete tentativas de entrega de mensagem com falha, expanda a seção **Delivery retry policy (HTTP/S)** (Política de repetição de entrega (HTTP/S)). Para obter mais informações, consulte [Novas tentativas de entrega de mensagens do Amazon SNS](sns-message-delivery-retries.md).

1. (Opcional) Para configurar como o Amazon SNS registra a entrega de mensagens CloudWatch, expanda a seção **Registro de status de entrega**. Para obter mais informações, consulte [Status de entrega de mensagens do Amazon SNS](sns-topic-attributes.md).

1. (Opcional) Para adicionar tags de metadados ao tópico, expanda a seção **Tags**, insira uma **Chave** e um **Valor** (opcional) e escolha **Adicionar tag**. Para obter mais informações, consulte [Marcação de tópicos do Amazon SNS](sns-tags.md).

1. Escolha **Criar tópico**.

   O tópico é criado e a ***MyTopic***página é exibida.

   O **nome** do tópico, o **ARN**, o **nome de exibição** (opcional) e o ID da AWS conta do **proprietário do tópico** são exibidos na seção **Detalhes**.

1. Copie o ARN do tópico para a área de transferência, por exemplo:

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

## Para criar um tópico usando um AWS SDK
<a name="create-topic-aws-sdks"></a>

Para usar um AWS SDK, você deve configurá-lo com suas credenciais. Para obter mais informações, consulte [Os arquivos compartilhados de configuração e credenciais no Guia](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) de *referência de ferramentas AWS SDKs e ferramentas*.

Os exemplos de código a seguir mostram como usar o `CreateTopic`.

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

**SDK para .NET**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SNS#code-examples). 
Crie um tópico com um nome específico.  

```
    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;
        }
    }
```
Crie um tópico com um nome e atributos específicos de FIFO e desduplicação.  

```
    /// <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;
    }
```
+  Para obter detalhes da API, consulte [CreateTopic](https://docs.aws.amazon.com/goto/DotNetSDKV3/sns-2010-03-31/CreateTopic)a *Referência AWS SDK para .NET da API*. 

------
#### [ C\$1\$1 ]

**SDK para C\$1\$1**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sns#code-examples). 

```
//! 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();
}
```
+  Para obter detalhes da API, consulte [CreateTopic](https://docs.aws.amazon.com/goto/SdkForCpp/sns-2010-03-31/CreateTopic)a *Referência AWS SDK para C\$1\$1 da API*. 

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

**AWS CLI**  
**Para criar um tópico do SNS**  
O exemplo `create-topic` a seguir cria um tópico do SNS chamado `my-topic`.  

```
aws sns create-topic \
    --name my-topic
```
Saída:  

```
{
    "ResponseMetadata": {
        "RequestId": "1469e8d7-1642-564e-b85d-a19b4b341f83"
    },
    "TopicArn": "arn:aws:sns:us-west-2:123456789012:my-topic"
}
```
Para obter mais informações, consulte [Usando a interface de linha de AWS comando com o Amazon SQS e o Amazon SNS](https://docs.aws.amazon.com/cli/latest/userguide/cli-sqs-queue-sns-topic.html) no Guia do usuário *AWS da interface de linha de comando*.  
+  Para obter detalhes da API, consulte [CreateTopic](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/create-topic.html)na *Referência de AWS CLI Comandos*. 

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

**SDK para Go V2**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/workflows/topics_and_queues#code-examples). 

```
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
}
```
+  Para obter detalhes da API, consulte [CreateTopic](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sns#Client.CreateTopic)a *Referência AWS SDK para Go da API*. 

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

**SDK para Java 2.x**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/sns#code-examples). 

```
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 "";
    }
}
```
+  Para obter detalhes da API, consulte [CreateTopic](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/CreateTopic)a *Referência AWS SDK for Java 2.x da API*. 

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

**SDK para JavaScript (v3)**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples). 
Crie o cliente em um módulo separado e exporte-o.  

```
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({});
```
Importe o SDK e os módulos do cliente e chame a API.  

```
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;
};
```
+  Para obter mais informações, consulte o [Guia do desenvolvedor do AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topics-createtopic). 
+  Para obter detalhes da API, consulte [CreateTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/CreateTopicCommand)a *Referência AWS SDK para JavaScript da API*. 

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

**SDK para Kotlin**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/sns#code-examples). 

```
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()
    }
}
```
+  Para obter detalhes da API, consulte a [CreateTopic](https://sdk.amazonaws.com/kotlin/api/latest/index.html)referência da API *AWS SDK for Kotlin*. 

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

**SDK para PHP**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [Repositório de exemplos de código da AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/sns#code-examples). 

```
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());
}
```
+  Para obter mais informações, consulte o [Guia do desenvolvedor do AWS SDK para PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-managing-topics.html#create-a-topic). 
+  Para obter detalhes da API, consulte [CreateTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/CreateTopic)a *Referência AWS SDK para PHP da API*. 

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

**SDK para Python (Boto3)**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/sns#code-examples). 

```
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
```
+  Para obter detalhes da API, consulte a [CreateTopic](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/CreateTopic)Referência da API *AWS SDK for Python (Boto3*). 

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

**SDK para Ruby**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [Repositório de exemplos de código da AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/sns#code-examples). 

```
# 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
```
+  Para obter mais informações, consulte o [Guia do desenvolvedor do AWS SDK para Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/sns-example-create-topic.html). 
+  Para obter detalhes da API, consulte [CreateTopic](https://docs.aws.amazon.com/goto/SdkForRubyV3/sns-2010-03-31/CreateTopic)a *Referência AWS SDK para Ruby da API*. 

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

**SDK para Rust**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/sns#code-examples). 

```
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(())
}
```
+  Para obter detalhes da API, consulte a [CreateTopic](https://docs.rs/aws-sdk-sns/latest/aws_sdk_sns/client/struct.Client.html#method.create_topic)referência da *API AWS SDK for Rust*. 

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

**SDK para SAP ABAP**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/sns#code-examples). 

```
    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.
```
+  Para obter detalhes da API, consulte a [CreateTopic](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*. 

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

**SDK para Swift**  
 Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/sns#code-examples). 

```
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
        }
```
+  Para obter detalhes da API, consulte [CreateTopic](https://sdk.amazonaws.com/swift/api/awssns/latest/documentation/awssns/snsclient/createtopic(input:))a *referência da API AWS SDK for Swift*. 

------