Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
Crear un SNS tema de Amazon
Un SNS tema de Amazon es un punto de acceso lógico que actúa como canal de comunicación. Un tema te permite agrupar varios puntos de enlace (como Amazon AWS Lambda SQS, HTTP /S o una dirección de correo electrónico).
Para difundir los mensajes de un sistema productor de mensajes (por ejemplo, un sitio web de comercio electrónico) que trabaja con otros servicios que requieren sus mensajes (por ejemplo, sistemas de pago y tramitación), puede crear un tema para su sistema productor.
La primera y más común SNS tarea de Amazon es crear un tema. Esta página muestra cómo puedes usar las AWS Management Console AWS SDK for Java, las y las AWS SDK for .NET para crear un tema.
Durante la creación, se elige un tipo de tema (estándar oFIFO) y se le asigna un nombre. Después de un tema, no podrá modificar el tipo o el nombre del tema. Todas las demás opciones de configuración son opcionales durante la creación del tema y puede editarlas más adelante.
No añada información de identificación personal (PII) ni ninguna otra información confidencial o delicada en los nombres de los temas. Otros Amazon Web Services, incluidos los CloudWatch registros, pueden acceder a los nombres de los temas. Los nombres de los temas no están diseñados para contener información privada o confidencial.
Para crear un tema utilizando el AWS Management Console
La creación de un tema en SNS Amazon sienta las bases para la distribución de mensajes, ya que te permite publicar mensajes que se pueden distribuir entre varios suscriptores. Este paso es esencial para configurar el tipo de tema, los ajustes de cifrado y las políticas de acceso, a fin de garantizar que el tema cumpla con los requisitos operativos, de conformidad y de seguridad de la organización.
Inicia sesión en la SNSconsola de Amazon.
-
Realice una de las siguientes acciones siguientes:
-
En la página Temas, elija Crear tema.
-
En la página Crear tema, en la sección Detalles, haga lo siguiente:
-
En Tipo, elija un tipo de tema (Estándar o FIFO).
-
Ingrese un nombre para el nuevo tema. Para un FIFOtema, añada .fifo al final del nombre.
-
(Opcional) Ingrese un nombre para mostrar para el tema.
Al suscribirse a un punto de enlace de correo electrónico, el número combinado de caracteres del nombre mostrado del SNS tema de Amazon y la dirección de correo electrónico remitente (por ejemplo, no-reply@sns.amazonaws.com) no debe superar los 320 UTF -8 caracteres. Puedes usar una herramienta de codificación de terceros para verificar la longitud de la dirección de envío antes de configurar un nombre visible para tu SNS tema de Amazon.
-
(Opcional) Para un FIFO tema, puede elegir la deduplicación de mensajes basada en el contenido para habilitar la deduplicación de mensajes predeterminada. Para obtener más información, consulte Deduplicación de SNS mensajes de Amazon para temas FIFO.
-
(Opcional) Expanda la sección Encryption (Cifrado) y haga lo siguiente. Para obtener más información, consulte Protección de SNS los datos de Amazon con cifrado del lado del servidor.
-
Elija Habilitar el cifrado.
-
Especifique la clave. AWS KMS Para obtener más información, consulte Términos clave.
Para cada KMS tipo, se muestran la descripción, la cuenta y KMSARNla cuenta.
Si no eres el propietario de la KMS cuenta o si inicias sesión con una cuenta que no tiene los kms:DescribeKey permisos kms:ListAliases y, no podrás ver la información KMS sobre la misma en la SNS consola de Amazon.
Solicita al propietario de la KMS que te conceda estos permisos. Para obtener más información, consulta la referencia sobre AWS KMS API permisos: acciones y recursos en la Guía para AWS Key Management Service desarrolladores.
-
La opción AWS Gestionado KMS para Amazon SNS (predeterminada) alias/aws/sns está seleccionada de forma predeterminada.
Tenga en cuenta lo siguiente:
-
La primera vez que utilices AWS Management Console para especificar el tema AWS gestionado KMS SNS para Amazon, se AWS KMS crea el AWS gestionado KMS para AmazonSNS.
-
Como alternativa, la primera vez que utilices la Publish acción en un tema con la SSE opción activada, se AWS KMS crea la acción AWS gestionada KMS para AmazonSNS.
-
Para usar una personalización KMS de tu AWS cuenta, selecciona el campo KMSclave y, a continuación, elige la personalización KMS de la lista.
Para obtener instrucciones sobre cómo crear una personalizadaKMSs, consulta Cómo crear claves en la Guía para AWS Key Management Service desarrolladores
-
Para usar una personalización KMS ARN de tu AWS cuenta o de otra AWS cuenta, introdúcela en el campo KMSclave.
-
(Opcional) De forma predeterminada, solo el propietario del tema puede publicar en el tema o suscribirse a este. Para configurar permisos de acceso adicionales, expanda la sección Access policy (Política de acceso). Para obtener más información, consulte Gestión de identidades y accesos en Amazon SNS y Ejemplos de casos de control de SNS acceso de Amazon.
Cuando se crea un tema a través de la consola, la política predeterminada utiliza la clave de condición aws:SourceOwner. Esta clave es similar a aws:SourceAccount.
-
(Opcional) Para configurar el modo en que Amazon SNS reintenta los intentos fallidos de entrega de mensajes, amplía la sección Política de reintentos de entrega (HTTP/S). Para obtener más información, consulte Amazon vuelve a intentarlo con la entrega de SNS mensajes.
-
(Opcional) Para configurar cómo Amazon SNS registra la entrega de mensajes CloudWatch, expande la sección Registro del estado de entrega. Para obtener más información, consulte Estado de entrega de SNS mensajes de Amazon.
-
(Opcional) Para añadir etiquetas de metadatos al tema, expanda la sección Tags (Etiquetas), escriba un valor en Key (Clave) y en Value (Valor) (opcional) y elija Add tag (Añadir etiqueta). Para obtener más información, consulte Etiquetado de SNS temas en Amazon.
-
Elija Crear nuevo tema.
Se crea el tema y el MyTopicse muestra la página.
El nombre del tema ARN, el nombre para mostrar (opcional) y el ID de AWS cuenta del propietario del tema se muestran en la sección de detalles.
-
Copia el tema ARN al portapapeles, por ejemplo:
arn:aws:sns:us-east-2:123456789012:MyTopic
Para crear un tema mediante un AWS SDK
Para usar un AWS SDK, debe configurarlo con sus credenciales. Para obtener más información, consulte Los archivos de configuración y credenciales compartidos en la Guía de referencia de herramientas AWS SDKs y herramientas.
En los siguientes ejemplos de código, se muestra cómo utilizar CreateTopic.
- .NET
-
- AWS SDK for .NET
-
Cree un tema con un nombre 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;
}
}
Cree un tema nuevo con un nombre y atributos específicos FIFO y de deduplicación.
/// <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 crear un tema de SNS
En el siguiente create-topic ejemplo se crea un SNS tema denominadomy-topic.
aws sns create-topic \
--name my-topic
Salida:
{
"ResponseMetadata": {
"RequestId": "1469e8d7-1642-564e-b85d-a19b4b341f83"
},
"TopicArn": "arn:aws:sns:us-west-2:123456789012:my-topic"
}
Para obtener más información, consulte Uso de la interfaz de línea de AWS comandos con Amazon SQS y Amazon SNS en la Guía del usuario de la interfaz de línea de AWS comandos.
- 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)
-
Cree el cliente en un módulo separado y expórtelo.
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 los módulos SDK y del cliente y llame alAPI.
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.
