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á.
Criação de um SNS tópico na Amazon
Um SNS tópico da Amazon é um ponto de acesso lógico que atua como um canal de comunicação. Um tópico permite agrupar vários endpoints (como Amazon AWS Lambda SQS, 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 primeira e mais comum SNS tarefa da Amazon é criar um tópico. Esta página mostra como você pode usar o AWS Management Console AWS SDK for Java, o e o AWS SDK for .NET para criar um tópico.
Durante a criação, você escolhe um tipo de tópico (padrão ouFIFO) 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.
Não adicione informações de identificação pessoal (PII) ou outras informações confidenciais ou sigilosas nos nomes dos 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 AWS Management Console
A criação de um tópico na 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.
Faça login no SNSconsole da Amazon.
-
Execute um destes procedimentos:
-
Na página Topics (Tópicos), escolha Create topic (Criar tópico).
-
Na página Create topic (Criar tópico), na seção Details (detalhes), faça o seguinte:
-
Em Tipo, escolha um tipo de tópico (Padrão ou FIFO).
-
Insira um Name (Nome) para o tópico. Para um FIFOtópico, adicione.fifo ao final do nome.
-
(Opcional) Insira um Display name (Nome para exibição) para o tópico.
Ao assinar um endpoint de e-mail, a contagem combinada de caracteres para o nome de exibição do SNS tópico da Amazon e o endereço de e-mail de envio (por exemplo, no-reply@sns.amazonaws.com) não deve exceder 320 UTF a 8 caracteres. Você pode usar uma ferramenta de codificação de terceiros para verificar o tamanho do endereço de envio antes de configurar um nome de exibição para seu tópico na AmazonSNS.
-
(Opcional) Para um FIFO tópico, você pode escolher a 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 SNS mensagens da Amazon para tópicos FIFO.
-
(Opcional) Expanda a seção Encryption (Criptografia) e faça o seguinte. Para obter mais informações, consulte Protegendo os SNS dados da Amazon com criptografia do lado do servidor.
-
Selecione Ativar criptografia.
-
Especifique a AWS KMS chave. Para obter mais informações, consulte Principais termos.
Para cada KMS tipo, a Descrição, a Conta e KMSARNsão exibidos.
Se você não for o proprietário doKMS, ou se fizer login com uma conta que não tenha as kms:DescribeKey
permissões kms:ListAliases
e, você não poderá visualizar informações sobre o KMS no SNS console da Amazon.
Peça ao proprietário do que KMS lhe conceda essas permissões. Para obter mais informações, consulte a Referência de AWS KMS API permissões: ações e recursos no Guia do AWS Key Management Service desenvolvedor.
-
O AWS gerenciado KMS para Amazon SNS (padrão) alias/aws/sns é selecionado por padrão.
Lembre-se do seguinte:
-
A primeira vez que você usa o AWS Management Console para especificar o AWS gerenciado KMS para a Amazon SNS para um tópico, AWS KMS cria o AWS gerenciado KMS para a AmazonSNS.
-
Como alternativa, na primeira vez em que você usa a Publish
ação em um tópico com SSE ativada, AWS KMS cria a ação AWS gerenciada KMS para a AmazonSNS.
-
Para usar um personalizado KMS da sua AWS conta, escolha o campo KMSchave e, em seguida, escolha o personalizado na KMS lista.
Para obter instruções sobre como criar chaves personalizadasKMSs, consulte Criação de chaves no Guia do AWS Key Management Service desenvolvedor
-
Para usar um personalizado KMS ARN da sua AWS conta ou de outra AWS conta, insira-o no campo KMSchave.
-
(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 ter mais informações, consulte Gerenciamento de identidade e acesso na Amazon SNS e Exemplos de casos de controle de SNS acesso da Amazon.
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
.
-
(Opcional) Para configurar como a Amazon SNS tenta novamente tentativas malsucedidas de entrega de mensagens, expanda a seção Política de nova tentativa de entrega (HTTP/S). Para obter mais informações, consulte Tentativas de entrega de SNS mensagens da Amazon.
-
(Opcional) Para configurar como a 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 SNS mensagens da Amazon.
-
(Opcional) Para adicionar tags de metadados ao tópico, expanda a seção Tags, insira uma Key (chave) e um Value (Valor) (opcional) e escolha Add tag (Adicionar tag). Para obter mais informações, consulte Marcação de SNS tópicos da Amazon.
-
Escolha Criar tópico.
O tópico é criado e o MyTopic
a página é exibida.
O nome do tópico 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.
-
Copie o tópico ARN 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
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 de referência de ferramentas AWS SDKs e ferramentas.
Os exemplos de código a seguir mostram como usar o CreateTopic
.
- .NET
-
- AWS SDK for .NET
-
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 novo tópico com um nome e atributos específicos FIFO e de eliminação de duplicaçã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;
}
- C++
-
- SDKpara C++
-
//! 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();
}
- CLI
-
- AWS CLI
-
Para criar um tópico do SNS
O create-topic
exemplo a seguir cria um SNS tópico chamadomy-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 a Amazon SQS e a Amazon SNS no Guia do usuário da interface de linha de AWS comando.
- Go
-
- SDKpara Go V2
-
// 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
}
- Java
-
- SDKpara Java 2.x
-
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 "";
}
}
- JavaScript
-
- SDKpara JavaScript (v3)
-
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 os módulos SDK e do cliente e chame API o.
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;
};
- Kotlin
-
- SDKpara Kotlin
-
suspend fun createSNSTopic(topicName: String): String {
val request =
CreateTopicRequest {
name = topicName
}
SnsClient { region = "us-east-1" }.use { snsClient ->
val result = snsClient.createTopic(request)
return result.topicArn.toString()
}
}
- PHP
-
- SDK para PHP
-
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());
}
- Python
-
- SDKpara Python (Boto3)
-
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
- Ruby
-
- SDKpara Ruby
-
# 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
- Rust
-
- SDKpara Rust
-
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(())
}
- SAP ABAP
-
- SDKpara SAP ABAP
-
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.