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'une rubrique Amazon SNS
Une rubrique Amazon SNS est un point d'accès logique qui joue le rôle de canal de communication. Une rubrique vous permet de regrouper plusieurs points de terminaison (tels qu'Amazon SQS AWS Lambda, 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 tâche Amazon SNS la plus importante et la plus courante consiste à créer une rubrique. 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 rubrique (standard ou FIFO) et vous nommez la rubrique. 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 de données d'identification personnelle (PII) ou d'autres données confidentielles ou sensibles dans les noms de rubriques. 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 console Amazon SNS.
-
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 rubrique (Standard ou FIFO).
-
Entrez un Nom pour la rubrique. Pour une rubrique FIFO, ajoutez .fifo à la fin du nom.
-
(Facultatif) Entrez un Nom d'affichage pour votre rubrique.
Lorsque vous vous abonnez à un point de terminaison d'e-mail, le nombre de caractères combinés pour le nom d'affichage de la rubrique Amazon SNS et l'adresse e-mail d'envoi (par exemple, no-reply@sns.amazonaws.com) ne doit pas dépasser 320 caractères UTF-8. Vous pouvez utiliser un outil d'encodage tiers pour vérifier la longueur de l'adresse d'envoi avant de configurer un nom d'affichage pour votre rubrique Amazon SNS.
-
(Facultatif) Pour une rubrique FIFO, vous pouvez choisir déduplication des messages basée sur le contenu pour activer la déduplication des messages par défaut. Pour plus d’informations, consultez Déduplication de message pour les rubriques FIFO.
-
(Facultatif) Développez la section Chiffrement et effectuez les opérations suivantes. Pour plus d’informations, consultez Chiffrement au repos.
-
Choisissez Activer le chiffrement.
-
Spécifiez la AWS KMS clé. Pour plus d’informations, consultez Termes clés.
Pour chaque type de KMS, les champs Description, Account (Compte) et KMS ARN (ARN KMS) s'affichent.
Si vous n'êtes pas le propriétaire de la clé KMS, ou si vous vous connectez avec un compte n'ayant pas les autorisations kms:ListAliases
et kms:DescribeKey
, vous ne pouvez pas afficher les informations relatives à la KMS sur la console Amazon SNS.
Demandez au propriétaire de la KMS de vous accorder ces autorisations. Pour plus d'informations, consultez Autorisations d'API AWS KMS : référence des actions et ressources dans le Guide du développeur AWS Key Management Service .
-
Le KMS AWS géré pour Amazon SNS (par défaut) alias/aws/sns 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 KMS AWS géré pour Amazon SNS pour une rubrique, le KMS AWS géré pour Amazon SNS est AWS KMS créé.
-
Sinon, la première fois que vous utilisez l'Publish
action sur un sujet pour lequel SSE est activé, le KMS AWS géré est AWS KMS créé pour Amazon SNS.
-
Pour utiliser un KMS personnalisé depuis votre AWS compte, choisissez le champ clé KMS, puis choisissez le KMS personnalisé dans la liste.
Pour obtenir des instructions pour la création de KMS personnalisées, consultez la section Création de clés dans le Guide du développeur AWS Key Management Service .
-
Pour utiliser un ARN KMS personnalisé à partir de votre AWS compte ou d'un autre AWS compte, saisissez-le dans le champ clé KMS.
-
(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 dans Amazon SNS et Cas d'exemple pour le contrôle d'accès Amazon SNS.
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 façon dont Amazon SNS retente la distribution des messages en échec, développez la section Politique de nouvelle tentative de distribution (HTTP/S). Pour plus d’informations, consultez Nouvelle tentative de distribution des messages Amazon SNS.
-
(Facultatif) Pour configurer la manière dont Amazon SNS enregistre la livraison des messages CloudWatch, développez la section Enregistrement de l'état de livraison. Pour plus d’informations, consultez Statut de distribution de message Amazon SNS.
-
(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 plus d’informations, consultez Identification des rubriques Amazon SNS.
-
Choisissez Créer une rubrique.
Le sujet est créé et la MyTopic
page s'affiche.
Le nom, l'ARN, le nom d'affichage (facultatif) et l'ID de AWS compte du propriétaire de la rubrique sont affichés dans la section Détails.
-
Copiez l'ARN de rubrique dans le Presse-papiers, par exemple :
arn:aws:sns:us-east-2:123456789012:MyTopic
Pour créer une rubrique à 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 Les fichiers de configuration et d'informations d'identification partagés dans le AWS Guide de référence des kits SDK 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 une nouvelle rubrique avec un nom et des attributs FIFO et de déduplication spécifiques.
/// <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++
-
- Kit SDK pour 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'exemple create-topic
suivant crée une rubrique SNS nommée my-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 AWS l'interface de ligne de commande.
- Go
-
- Kit SDK for 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
-
- Kit SDK pour 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
-
- SDK pour 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 le kit SDK et les modules client et appelez l’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;
};
- Kotlin
-
- Kits SDK pour 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
-
- Kit 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
-
- Kit SDK pour 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
-
- Kit SDK pour 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
-
- Kit SDK pour 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
-
- Kit SDK pour 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.