Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
Création d'un SNS sujet Amazon
Une SNS rubrique Amazon est un point d'accès logique qui fait office de canal de communication. Une rubrique vous permet de regrouper plusieurs points de terminaison (tels qu'Amazon AWS Lambda SQS, HTTP /S ou une adresse e-mail).
Pour diffuser les messages d'un système producteur de messages (par exemple, un site web d'e-commerce) qui utilise plusieurs autres services ayant besoin de ses messages (par exemple, les systèmes d'enregistrement et de distribution de commandes), vous pouvez créer une rubrique pour votre système producteur.
La première SNS tâche d'Amazon, et la plus courante, consiste à créer un sujet. Cette page montre comment vous pouvez utiliser le AWS Management Console AWS SDK for Java, le et le AWS SDK for .NET pour créer un sujet.
Lors de la création, vous choisissez un type de sujet (standard ouFIFO) et nommez-le. Après avoir créé une rubrique, vous ne pouvez pas modifier son type ou son nom. Tous les autres choix de configuration sont facultatifs lors de la création d'une rubrique et vous pouvez les modifier ultérieurement.
N'ajoutez pas d'informations personnellement identifiables (PII) ou d'autres informations confidentielles ou sensibles dans les noms des sujets. Les noms des rubriques sont accessibles aux autres Amazon Web Services, y compris aux CloudWatch journaux. Les noms de rubriques ne sont pas destinées à être utilisées pour des données privées ou sensibles.
Pour créer un sujet à l'aide du AWS Management Console
Connectez-vous à la SNSconsole Amazon.
-
Effectuez l’une des actions suivantes :
-
Sur la page Rubriques, choisissez Créer une rubrique.
-
Sur la page Créer une rubrique, dans la section Détails, procédez comme suit :
-
Pour Type, choisissez un type de sujet (Standard ou FIFO).
-
Entrez un Nom pour la rubrique. Pour un FIFOsujet, ajoutez .fifo à la fin du nom.
-
(Facultatif) Entrez un Nom d'affichage pour votre rubrique.
Lorsque vous vous abonnez à un point de terminaison de messagerie, le nombre de caractères combiné pour le nom d'affichage de la SNS rubrique Amazon et l'adresse e-mail d'envoi (par exemple, no-reply@sns.amazonaws.com) ne doit pas dépasser 320 à UTF 8 caractères. Vous pouvez utiliser un outil de codage tiers pour vérifier la longueur de l'adresse d'envoi avant de configurer un nom d'affichage pour votre SNS rubrique Amazon.
-
(Facultatif) Pour un FIFO sujet, vous pouvez choisir la déduplication des messages basée sur le contenu pour activer la déduplication des messages par défaut. Pour de plus amples informations, veuillez consulter Déduplication des messages pour les rubriques FIFO.
-
(Facultatif) Développez la section Chiffrement et effectuez les opérations suivantes. Pour de plus amples informations, veuillez consulter Chiffrement au repos.
-
Choisissez Activer le chiffrement.
-
Spécifiez la AWS KMS clé. Pour de plus amples informations, veuillez consulter Termes clés.
Pour chaque KMS type, la description, le compte et le numéro KMSARN1 sont affichés.
Si vous n'êtes pas le propriétaire duKMS, ou si vous vous connectez avec un compte ne disposant pas des kms:DescribeKey autorisations kms:ListAliases et, vous ne pourrez pas consulter les informations le concernant KMS sur la SNS console Amazon.
Demandez au propriétaire de vous KMS accorder ces autorisations. Pour plus d'informations, consultez la référence AWS KMS API Permissions : actions et ressources dans le guide du AWS Key Management Service développeur.
-
L'alias/aws/sns AWS géré KMS pour Amazon SNS (par défaut) est sélectionné par défaut.
Gardez à l'esprit les points suivants :
-
La première fois que vous utilisez le AWS Management Console pour spécifier le AWS géré KMS pour Amazon SNS pour un sujet, AWS KMS cela crée le AWS géré KMS pour AmazonSNS.
-
Sinon, la première fois que vous utilisez l'Publishaction sur un sujet SSE activé, l'action AWS gérée KMS pour Amazon est AWS KMS crééeSNS.
-
Pour utiliser une personnalisation KMS depuis votre AWS compte, choisissez le champ KMSclé, puis choisissez la personnalisation dans la KMS liste.
Pour obtenir des instructions sur la création de clés personnaliséesKMSs, voir Création de clés dans le guide du AWS Key Management Service développeur
-
Pour utiliser une personnalisation KMS ARN de votre AWS compte ou d'un autre AWS compte, saisissez-la dans le champ KMSclé.
-
(Facultatif) Par défaut, seul le propriétaire de la rubrique peut publier dans la rubrique ou s'abonner à la rubrique. Pour configurer des autorisations d'accès supplémentaires, développez la section Politique d'accès. Pour plus d’informations, consultez Gestion des identités et des accès sur Amazon SNS et Exemples de cas relatifs SNS au contrôle d'accès Amazon.
Lorsque vous créez une rubrique à l'aide de la console, la politique par défaut utilise la clé de condition aws:SourceOwner. Cette clé est similaire à aws:SourceAccount.
-
(Facultatif) Pour configurer la manière dont Amazon SNS tente à nouveau les tentatives de livraison de messages ayant échoué, développez la section Politique de nouvelles tentatives de livraison (HTTP/S). Pour de plus amples informations, veuillez consulter Rétentatives de livraison de SNS messages Amazon.
-
(Facultatif) Pour configurer la manière dont Amazon SNS enregistre l'envoi des messages CloudWatch, développez la section Enregistrement du statut de livraison. Pour de plus amples informations, veuillez consulter État de livraison des SNS messages Amazon.
-
(Facultatif) Pour ajouter des balises de métadonnées à la rubrique, développez la section Balises, saisissez une clé et une valeur (facultatif) et choisissez Ajouter une balise. Pour de plus amples informations, veuillez consulter Balisage des SNS rubriques Amazon.
-
Choisissez Créer une rubrique.
Le sujet est créé et le MyTopicla page s'affiche.
Le nom du sujet ARN, le nom d'affichage (facultatif) et l'identifiant de AWS compte du propriétaire du sujet sont affichés dans la section Détails.
-
Copiez le sujet ARN dans le presse-papiers, par exemple :
arn:aws:sns:us-east-2:123456789012:MyTopic
Pour créer un sujet à l'aide d'un AWS SDK
Pour utiliser un AWS SDK, vous devez le configurer avec vos informations d'identification. Pour plus d'informations, consultez la section Les fichiers de configuration et d'identification partagés dans le guide de référence des outils AWS SDKs et des outils.
Les exemples de code suivants montrent comment utiliserCreateTopic.
- .NET
-
- AWS SDK for .NET
-
Créez une rubrique avec un nom spécifique.
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;
}
}
Créez un nouveau sujet avec un nom et des attributs spécifiques FIFO et de déduplication.
/// <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++
-
- SDKpour 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
-
Pour créer une rubrique SNS
L'create-topicexemple suivant crée une SNS rubrique nomméemy-topic.
aws sns create-topic \
--name my-topic
Sortie :
{
"ResponseMetadata": {
"RequestId": "1469e8d7-1642-564e-b85d-a19b4b341f83"
},
"TopicArn": "arn:aws:sns:us-west-2:123456789012:my-topic"
}
Pour plus d'informations, consultez la section Utilisation de l'interface de ligne de AWS commande avec Amazon SQS et Amazon SNS dans le guide de l'utilisateur de l'interface de ligne de AWS commande.
- Go
-
- SDKpour 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(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(context.TODO(), &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
-
- SDKpour 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
-
- SDKpour JavaScript (v3)
-
Créez le client dans un module séparé et exportez-le.
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({});
Importez SDK les modules client et appelez leAPI.
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
-
- SDKpour 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 pour 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
-
- SDKpour 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
-
- SDKpour 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
-
- SDKpour 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
-
- SDKpour 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.
