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 et publication de messages
Cette rubrique décrit les étapes de base de la gestion des ressources Amazon SNS, notamment en ce qui concerne les sujets, les abonnements et la publication de messages. Tout d'abord, vous allez configurer les autorisations d'accès nécessaires pour Amazon SNS, en vous assurant de disposer des autorisations appropriées pour créer et gérer les ressources Amazon SNS. Vous allez ensuite créer une nouvelle rubrique Amazon SNS, qui servira de plateforme centrale pour la gestion et la distribution des messages aux abonnés. Après avoir créé le sujet, vous allez créer un abonnement à ce sujet, permettant à des points de terminaison spécifiques de recevoir les messages publiés sur ce sujet.
Une fois le sujet et l'abonnement définis, vous publierez un message sur le sujet, en observant comment Amazon SNS transmet efficacement le message à tous les points de terminaison abonnés. Enfin, vous apprendrez comment supprimer à la fois l'abonnement et le sujet, pour terminer le cycle de vie des ressources Amazon SNS que vous avez gérées. Cette approche vous permet de bien comprendre les opérations fondamentales d'Amazon SNS et d'acquérir les compétences pratiques nécessaires pour gérer les flux de travail de messagerie à l'aide de la console Amazon SNS.
# Configuration de l'accès à Amazon SNS
Avant de pouvoir utiliser Amazon SNS, vous devez suivre la procédure ci-dessous.
## Création d'un utilisateur Compte AWS et d'un utilisateur IAM
Pour accéder à AWS un service, vous devez d'abord créer un [Compte AWS](https://aws.amazon.com/). Vous pouvez utiliser votre Compte AWS pour consulter vos rapports d'activité et d'utilisation et pour gérer l'authentification et l'accès.
### Inscrivez-vous pour un Compte AWS
Si vous n'en avez pas Compte AWS, procédez comme suit pour en créer un.
**Pour vous inscrire à un Compte AWS**
1. Ouvrez l'[https://portal.aws.amazon.com/billing/inscription.](https://portal.aws.amazon.com/billing/signup)
1. Suivez les instructions en ligne.
Dans le cadre de la procédure d’inscription, vous recevrez un appel téléphonique ou un SMS et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.
Lorsque vous vous inscrivez à un Compte AWS, un *utilisateur Compte AWS root* est créé. Par défaut, seul l’utilisateur racine a accès à l’ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur, et à utiliser uniquement l’utilisateur racine pour effectuer les [tâches nécessitant un accès utilisateur racine](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS vous envoie un e-mail de confirmation une fois le processus d'inscription terminé. À tout moment, vous pouvez consulter l'activité actuelle de votre compte et gérer votre compte en accédant à [https://aws.amazon.com/](https://aws.amazon.com/)et en choisissant **Mon compte**.
### Création d’un utilisateur doté d’un accès administratif
Une fois que vous vous êtes inscrit Compte AWS, sécurisez votre utilisateur Compte AWS root AWS IAM Identity Center, activez et créez un utilisateur administratif afin de ne pas utiliser l'utilisateur root pour les tâches quotidiennes.
**Sécurisez votre utilisateur Compte AWS root**
1. Connectez-vous en [AWS Management Console](https://console.aws.amazon.com/)tant que propriétaire du compte en choisissant **Utilisateur root** et en saisissant votre adresse Compte AWS e-mail. Sur la page suivante, saisissez votre mot de passe.
Pour obtenir de l’aide pour vous connecter en utilisant l’utilisateur racine, consultez [Connexion en tant qu’utilisateur racine](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) dans le *Guide de l’utilisateur Connexion à AWS *.
1. Activez l’authentification multifactorielle (MFA) pour votre utilisateur racine.
Pour obtenir des instructions, voir [Activer un périphérique MFA virtuel pour votre utilisateur Compte AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) dans le guide de l'utilisateur *IAM*.
**Création d’un utilisateur doté d’un accès administratif**
1. Activez IAM Identity Center.
Pour obtenir des instructions, consultez [Activation d’ AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
1. Dans IAM Identity Center, octroyez un accès administratif à un utilisateur.
Pour un didacticiel sur l'utilisation du Répertoire IAM Identity Center comme source d'identité, voir [Configurer l'accès utilisateur par défaut Répertoire IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) dans le *Guide de AWS IAM Identity Center l'utilisateur*.
**Connexion en tant qu’utilisateur doté d’un accès administratif**
+ Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l’URL de connexion qui a été envoyée à votre adresse e-mail lorsque vous avez créé l’utilisateur IAM Identity Center.
Pour obtenir de l'aide pour vous connecter en utilisant un utilisateur d'IAM Identity Center, consultez la section [Connexion au portail AWS d'accès](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) dans le *guide de l'Connexion à AWS utilisateur*.
**Attribution d’un accès à d’autres utilisateurs**
1. Dans IAM Identity Center, créez un ensemble d’autorisations qui respecte la bonne pratique consistant à appliquer les autorisations de moindre privilège.
Pour obtenir des instructions, consultez [Création d’un ensemble d’autorisations](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
1. Attribuez des utilisateurs à un groupe, puis attribuez un accès par authentification unique au groupe.
Pour obtenir des instructions, consultez [Ajout de groupes](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.
## Étapes suivantes
Maintenant que vous êtes prêt à travailler avec Amazon SNS, commencez par :
1. [Création d'une rubrique Amazon SNS](sns-create-topic.md)
1. [Création d'un abonnement à une rubrique Amazon SNS](sns-create-subscribe-endpoint-to-topic.md)
1. [Publication d'un message Amazon SNS](sns-publishing.md)
1. [Supprimer un sujet et un abonnement Amazon SNS](sns-delete-subscription-topic.md)
# 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 pour Java, le et le AWS SDK pour .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.
**Important**
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
La création d'un sujet dans Amazon SNS pose les bases de la distribution de messages, vous permettant de publier des messages qui peuvent être transmis à plusieurs abonnés. Cette étape est essentielle pour configurer le type de sujet, les paramètres de chiffrement et les politiques d'accès, afin de garantir que le sujet répond aux exigences opérationnelles, de conformité et de sécurité de l'organisation.
1. Connectez-vous à la [console Amazon SNS](https://console.aws.amazon.com/sns/home).
1. Effectuez l’une des actions suivantes :
+ Si aucun sujet n'a encore été créé sous votre Compte AWS nom, lisez la description d'Amazon SNS sur la page d'accueil.
+ Si des sujets ont déjà été créés sous votre Compte AWS nom, dans le panneau de navigation, sélectionnez **Sujets**.
1. Sur la page **Rubriques**, choisissez **Créer une rubrique**.
1. Sur la page **Créer une rubrique**, dans la section **Détails**, procédez comme suit :
1. Pour **Type**, choisissez un type de rubrique (**Standard** ou **FIFO**).
1. Entrez un **Nom** pour la rubrique. Pour une [rubrique FIFO](sns-fifo-topics.md), ajoutez **.fifo** à la fin du nom.
1. (Facultatif) Entrez un **Nom d'affichage** pour votre rubrique.
**Important**
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.
1. (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 de plus amples informations, veuillez consulter [Déduplication des messages Amazon SNS pour les rubriques FIFO](fifo-message-dedup.md).
1. (Facultatif) Développez la section **Chiffrement** et effectuez les opérations suivantes. Pour de plus amples informations, veuillez consulter [Sécurisation des données Amazon SNS grâce au chiffrement côté serveur](sns-server-side-encryption.md).
1. Choisissez **Activer le chiffrement**.
1. Spécifiez la AWS KMS clé. Pour de plus amples informations, veuillez consulter [Termes clés](sns-server-side-encryption.md#sse-key-terms).
Pour chaque type de KMS, les champs **Description**, **Account (Compte)** et **KMS ARN (ARN KMS)** s'affichent.
**Important**
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](https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html) 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.
**Note**
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.
**Note**
Pour obtenir des instructions sur la création de clés personnalisées KMSs, voir [Création de clés](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) dans le *guide du AWS Key Management Service développeur*
+ Pour utiliser un ARN KMS personnalisé à partir de votre AWS compte ou d'un autre AWS compte, saisissez-le dans le champ **clé KMS**.
1. (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](security-iam.md) et [Cas d'exemple pour le contrôle d'accès Amazon SNS](sns-access-policy-use-cases.md).
**Note**
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`.
1. (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 de plus amples informations, veuillez consulter [Nouvelle tentative de distribution des messages Amazon SNS](sns-message-delivery-retries.md).
1. (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 de plus amples informations, veuillez consulter [Statut de distribution de message Amazon SNS](sns-topic-attributes.md).
1. (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 [Identification des rubriques Amazon SNS](sns-tags.md).
1. 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 du sujet** sont affichés dans la section **Détails**.
1. 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 [la section Les fichiers de configuration et d'identification partagés](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) dans le *guide de référence des outils AWS SDKs et des outils*.
Les exemples de code suivants illustrent comment utiliser `CreateTopic`.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SNS#code-examples).
Créez une rubrique avec un nom spécifique.
```
using System;
using System.Threading.Tasks;
using Amazon.SimpleNotificationService;
using Amazon.SimpleNotificationService.Model;
///
/// This example shows how to use Amazon Simple Notification Service
/// (Amazon SNS) to add a new Amazon SNS topic.
///
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}");
}
///
/// Creates a new SNS topic using the supplied topic name.
///
/// The initialized SNS client object used to
/// create the new topic.
/// A string representing the topic name.
/// The Amazon Resource Name (ARN) of the created topic.
public static async Task 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.
```
///
/// Create a new topic with a name and specific FIFO and de-duplication attributes.
///
/// The name for the topic.
/// True to use a FIFO topic.
/// True to use content-based de-duplication.
/// The ARN of the new topic.
public async Task 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
{
{ "FifoTopic", "true" }
};
if (useContentBasedDeduplication)
{
createTopicRequest.Attributes.Add("ContentBasedDeduplication", "true");
}
}
var createResponse = await _amazonSNSClient.CreateTopicAsync(createTopicRequest);
return createResponse.TopicArn;
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/goto/DotNetSDKV3/sns-2010-03-31/CreateTopic)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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();
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/goto/SdkForCpp/sns-2010-03-31/CreateTopic)à la section *Référence des AWS SDK pour C\$1\$1 API*.
------
#### [ 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](https://docs.aws.amazon.com/cli/latest/userguide/cli-sqs-queue-sns-topic.html) dans le Guide de l'utilisateur de *AWS l'interface de ligne de commande*.
+ Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/create-topic.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sns#Client.CreateTopic)à la section *Référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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:
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 "";
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/CreateTopic)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
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;
};
```
+ Pour plus d’informations, consultez le [AWS SDK pour JavaScript Guide du développeur](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topics-createtopic).
+ Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/CreateTopicCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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()
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://sdk.amazonaws.com/kotlin/api/latest/index.html)à la section *AWS SDK pour la référence de l'API Kotlin*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code 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());
}
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-managing-topics.html#create-a-topic).
+ Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/CreateTopic)à la section *Référence des AWS SDK pour PHP API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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
```
+ Pour plus de détails sur l'API, consultez [CreateTopic](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/CreateTopic)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code 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
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/sns-example-create-topic.html).
+ Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/goto/SdkForRubyV3/sns-2010-03-31/CreateTopic)à la section *Référence des AWS SDK pour Ruby API*.
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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(())
}
```
+ Pour plus de détails sur l'API, voir [CreateTopic](https://docs.rs/aws-sdk-sns/latest/aws_sdk_sns/client/struct.Client.html#method.create_topic)la section de *référence de l'API AWS SDK for Rust*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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.
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateTopic](https://sdk.amazonaws.com/swift/api/awssns/latest/documentation/awssns/snsclient/createtopic(input:))à la section *AWS SDK pour la référence de l'API Swift*.
------
# Création d'un abonnement à une rubrique Amazon SNS
Pour recevoir les messages publiés dans [une rubrique](sns-create-topic.md), vous devez *abonner* un [point de terminaison](#sns-endpoints) à cette rubrique. Une fois que vous avez abonné un point de terminaison à une rubrique, le point de terminaison commence à recevoir tous les messages publiés dans la rubrique associée.
**Note**
Les points de terminaison, adresses e-mail et AWS ressources HTTP (S) dans d'autres domaines Comptes AWS nécessitent une confirmation de l'abonnement avant de pouvoir recevoir des messages.
## Pour abonner un point de terminaison à une rubrique Amazon SNS
L'abonnement d'un point de terminaison à une rubrique Amazon SNS permet de transmettre des messages au point de terminaison spécifié, garantissant ainsi que les bons systèmes ou utilisateurs reçoivent des notifications lorsqu'un message est publié sur le sujet. Cette étape est essentielle pour relier le sujet aux consommateurs, qu'il s'agisse d'applications, de destinataires d'e-mails ou d'autres services, afin d'assurer une communication fluide entre les systèmes.
1. Connectez-vous à la [console Amazon SNS](https://console.aws.amazon.com/sns/home).
1. Dans le volet de navigation de gauche, choisissez **Subscriptions (Abonnements)**.
1. Sur la page **Abonnements**, choisissez **Créer un abonnement**.
1. Sur la page **Créer un abonnement**, dans la section **Détails**, procédez comme suit :
1. Pour **ARN de rubrique**, choisissez l'ARN (Amazon Resource Name) d'une rubrique. Cette valeur est l' AWS ARN généré lorsque vous avez créé la rubrique Amazon SNS, par exemple. `arn:aws:sns:us-east-2:123456789012:your_topic`
1. Pour **Protocole**, choisissez un type de point de terminaison. Les types de point de terminaison disponibles sont les suivants :
+ [**HTTP/HTTPS**](sns-http-https-endpoint-as-subscriber.md)
+ [**E-mail/E-mail-JSON**](sns-email-notifications.md)
+ [****](sns-firehose-as-subscriber.md)
+ [**Amazon SQS**](sns-sqs-as-subscriber.md)
**Note**
Pour vous abonner à une [Rubrique SNS FIFO](sns-fifo-topics.md), choisissez cette option.
+ [**AWS Lambda**](sns-lambda-as-subscriber.md)
+ [**Point de terminaison de l'application de plateforme**](sns-mobile-application-as-subscriber.md)
+ [**SMS**](sns-mobile-phone-number-as-subscriber.md)
1. Pour **Point de terminaison**, saisissez la valeur du point de terminaison, telle qu'une adresse e-mail ou l'ARN d'une file d'attente Amazon SQS.
1. Points de terminaison Firehose uniquement : pour l'**ARN du rôle** d'abonnement, spécifiez l'ARN du rôle IAM que vous avez créé pour écrire dans les flux de diffusion Firehose. Pour de plus amples informations, veuillez consulter [Conditions requises pour abonner les flux de diffusion Firehose aux rubriques Amazon SNS](prereqs-kinesis-data-firehose.md).
1. (Facultatif) Pour Firehose, Amazon SQS et les points de terminaison HTTP/S , vous pouvez également activer la livraison de messages bruts. Pour de plus amples informations, veuillez consulter [Remise des messages bruts Amazon SNS](sns-large-payload-raw-message-delivery.md).
1. (Facultatif) Pour configurer une politique de filtre, développez la section **Politique de filtre d'abonnement**. Pour de plus amples informations, veuillez consulter [Stratégies de filtre d'abonnement Amazon SNS](sns-subscription-filter-policies.md).
1. (Facultatif) Pour activer le filtrage basé sur la charge utile, configurez `Filter Policy Scope` sur `MessageBody`. Pour de plus amples informations, veuillez consulter [Étendue de la politique de filtre d'abonnement Amazon SNS](sns-message-filtering-scope.md).
1. (Facultatif) Pour configurer une file d’attente de lettres mortes pour l’abonnement, développez la section **Politique de reconduite (File d’attente de lettres mortes).** Pour de plus amples informations, consultez la section [Files d'attente pour les lettres mortes Amazon SNS](sns-dead-letter-queues.md).
1. Choisissez **Créer un abonnement**.
La console crée l'abonnement et ouvre la page **Détails** de l’abonnement.
# Publication d'un message Amazon SNS
Une fois que vous avez [créé une rubrique Amazon SNS](sns-create-topic.md) et y avez [abonné](sns-create-subscribe-endpoint-to-topic.md) un point de terminaison, vous pouvez y *publier* des messages. Lorsqu'un message est publié, Amazon SNS tente de le remettre aux [points de terminaison](sns-create-subscribe-endpoint-to-topic.md#sns-endpoints) abonnés.
## Pour publier des messages sur des rubriques Amazon SNS à l'aide du AWS Management Console
1. Connectez-vous à la [console Amazon SNS](https://console.aws.amazon.com/sns/home).
1. Dans le panneau de navigation de gauche, choisissez **Rubriques**.
1. Sur la page **Rubriques**, sélectionnez une rubrique, puis choisissez **Publier un message**.
La console ouvre la fenêtre **Publier un message sur une rubrique**.
1. Dans la section **Détails de base**, procédez comme suit :
1. (Facultatif) Saisissez un message dans le champ **Objet**.
1. Pour une [rubrique FIFO](sns-fifo-topics.md), saisissez une valeur d'**ID de groupe de messages**. L'**identifiant du groupe de messages** est requis pour les sujets FIFO. Les messages du même groupe de messages sont remis dans l'ordre dans lequel ils sont publiés.
1. (Facultatif) Pour un sujet standard, entrez un **ID de groupe de messages**. Cet identifiant est transmis à tous les abonnements standard Amazon SQS et n'est ni utilisé ni envoyé à aucun autre type de point de terminaison.
1. Pour une rubrique FIFO, saisissez un **ID de déduplication de message**. Cet ID est facultatif si vous avez activé l'option **Déduplication des messages basée sur le contenu** pour la rubrique.
1. (Facultatif) Pour [notifications push mobile](sns-ttl.md), saisissez une valeur de **Durée de vie (TTL)** en secondes. Il s'agit du délai dont dispose un service de notification push, tel que Apple Push Notification Service (APNs) ou Firebase Cloud Messaging (FCM), pour transmettre le message au terminal.
1. Dans la section **Message body (Corps du messages)**, effectuez l'une des actions suivantes :
1. Choisissez **Charge utile identique pour tous les protocoles de livraison**, puis saisissez un message.
1. Choisissez **Charge utile personnalisée pour chaque protocole de distribution**, puis utilisez un objet JSON pour définir le message à envoyer à chaque protocole.
Pour de plus amples informations, veuillez consulter [Publication de notifications Amazon SNS avec des charges utiles spécifiques à la plate-forme](sns-send-custom-platform-specific-payloads-mobile-devices.md).
1. Dans la section **Attributs du message**, ajoutez tous les attributs que vous souhaitez qu'Amazon SNS associe à l'attribut d'abonnement `FilterPolicy` afin de déterminer si le point de terminaison abonné est intéressé par le message publié.
1. Pour **Type**, choisissez un type d'attribut, tel que **String.Array**.
**Note**
Pour le type d'attribut **String.Array**, placez le tableau entre crochets (`[]`). Dans le tableau, placez les chaînes entre guillemets. Vous n'avez pas besoin de guillemets pour les chiffres ou les mots-clés `true`, `false` et `null`.
1. Saisissez un attribut **Nom**, comme `customer_interests`.
1. Saisissez un attribut **Valeur**, comme `["soccer", "rugby", "hockey"]`.
Si le type d'attribut est **String**, **String.Array** ou **Number**, Amazon SNS évalue l'attribut du message par rapport à la [politique de filtre](sns-message-filtering.md) d'un abonnement, le cas échéant, avant d'envoyer le message à cet abonnement, étant donné que l'étendue de la politique de filtre n'est pas explicitement définie sur `MessageBody`.
Pour de plus amples informations, veuillez consulter [Attributs de message Amazon SNS](sns-message-attributes.md).
1. Choisissez **Publier le message**.
Le message est publié dans la rubrique et la console ouvre la page **Détails** de la rubrique.
## Pour publier un message dans 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 [la section Les fichiers de configuration et d'identification partagés](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) dans le *guide de référence des outils AWS SDKs et des outils*.
Les exemples de code suivants illustrent comment utiliser `Publish`.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SNS#code-examples).
Publier un message dans une rubrique
```
using System;
using System.Threading.Tasks;
using Amazon.SimpleNotificationService;
using Amazon.SimpleNotificationService.Model;
///
/// This example publishes a message to an Amazon Simple Notification
/// Service (Amazon SNS) topic.
///
public class PublishToSNSTopic
{
public static async Task Main()
{
string topicArn = "arn:aws:sns:us-east-2:000000000000:ExampleSNSTopic";
string messageText = "This is an example message to publish to the ExampleSNSTopic.";
IAmazonSimpleNotificationService client = new AmazonSimpleNotificationServiceClient();
await PublishToTopicAsync(client, topicArn, messageText);
}
///
/// Publishes a message to an Amazon SNS topic.
///
/// The initialized client object used to publish
/// to the Amazon SNS topic.
/// The ARN of the topic.
/// The text of the message.
public static async Task PublishToTopicAsync(
IAmazonSimpleNotificationService client,
string topicArn,
string messageText)
{
var request = new PublishRequest
{
TopicArn = topicArn,
Message = messageText,
};
var response = await client.PublishAsync(request);
Console.WriteLine($"Successfully published message ID: {response.MessageId}");
}
}
```
Publiez un message dans une rubrique avec des options de groupe, de duplication et d’attribut.
```
///
/// Publish messages using user settings.
///
/// Async task.
public static async Task PublishMessages()
{
Console.WriteLine("Now we can publish messages.");
var keepSendingMessages = true;
string? deduplicationId = null;
string? toneAttribute = null;
while (keepSendingMessages)
{
Console.WriteLine();
var message = GetUserResponse("Enter a message to publish.", "This is a sample message");
if (_useFifoTopic)
{
Console.WriteLine("Because you are using a FIFO topic, you must set a message group ID." +
"\r\nAll messages within the same group will be received in the order " +
"they were published.");
Console.WriteLine();
var messageGroupId = GetUserResponse("Enter a message group ID for this message:", "1");
if (!_useContentBasedDeduplication)
{
Console.WriteLine("Because you are not using content-based deduplication, " +
"you must enter a deduplication ID.");
Console.WriteLine("Enter a deduplication ID for this message.");
deduplicationId = GetUserResponse("Enter a deduplication ID for this message.", "1");
}
if (GetYesNoResponse("Add an attribute to this message?"))
{
Console.WriteLine("Enter a number for an attribute.");
for (int i = 0; i < _tones.Length; i++)
{
Console.WriteLine($"\t{i + 1}. {_tones[i]}");
}
var selection = GetUserResponse("", "1");
int.TryParse(selection, out var selectionNumber);
if (selectionNumber > 0 && selectionNumber < _tones.Length)
{
toneAttribute = _tones[selectionNumber - 1];
}
}
var messageID = await SnsWrapper.PublishToTopicWithAttribute(
_topicArn, message, "tone", toneAttribute, deduplicationId, messageGroupId);
Console.WriteLine($"Message published with id {messageID}.");
}
keepSendingMessages = GetYesNoResponse("Send another message?", false);
}
}
```
Appliquez les sélections de l’utilisateur à l’action de publication.
```
///
/// Publish a message to a topic with an attribute and optional deduplication and group IDs.
///
/// The ARN of the topic.
/// The message to publish.
/// The optional attribute for the message.
/// The optional attribute value for the message.
/// The optional deduplication ID for the message.
/// The optional group ID for the message.
/// The ID of the message published.
public async Task PublishToTopicWithAttribute(
string topicArn,
string message,
string? attributeName = null,
string? attributeValue = null,
string? deduplicationId = null,
string? groupId = null)
{
var publishRequest = new PublishRequest()
{
TopicArn = topicArn,
Message = message,
MessageDeduplicationId = deduplicationId,
MessageGroupId = groupId
};
if (attributeValue != null)
{
// Add the string attribute if it exists.
publishRequest.MessageAttributes =
new Dictionary
{
{ attributeName!, new MessageAttributeValue() { StringValue = attributeValue, DataType = "String"} }
};
}
var publishResponse = await _amazonSNSClient.PublishAsync(publishRequest);
return publishResponse.MessageId;
}
```
+ Pour plus de détails sur l’API, consultez [Publish](https://docs.aws.amazon.com/goto/DotNetSDKV3/sns-2010-03-31/Publish) dans la *Référence des API du kit AWS SDK pour .NET *.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sns#code-examples).
```
//! Send a message to an Amazon Simple Notification Service (Amazon SNS) topic.
/*!
\param message: The message to publish.
\param topicARN: The Amazon Resource Name (ARN) for an Amazon SNS topic.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SNS::publishToTopic(const Aws::String &message,
const Aws::String &topicARN,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SNS::SNSClient snsClient(clientConfiguration);
Aws::SNS::Model::PublishRequest request;
request.SetMessage(message);
request.SetTopicArn(topicARN);
const Aws::SNS::Model::PublishOutcome outcome = snsClient.Publish(request);
if (outcome.IsSuccess()) {
std::cout << "Message published successfully with id '"
<< outcome.GetResult().GetMessageId() << "'." << std::endl;
}
else {
std::cerr << "Error while publishing message "
<< outcome.GetError().GetMessage()
<< std::endl;
}
return outcome.IsSuccess();
}
```
Publiez un message avec un attribut.
```
static const Aws::String TONE_ATTRIBUTE("tone");
static const Aws::Vector TONES = {"cheerful", "funny", "serious",
"sincere"};
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
Aws::SNS::SNSClient snsClient(clientConfiguration);
Aws::SNS::Model::PublishRequest request;
request.SetTopicArn(topicARN);
Aws::String message = askQuestion("Enter a message text to publish. ");
request.SetMessage(message);
if (filteringMessages && askYesNoQuestion(
"Add an attribute to this message? (y/n) ")) {
for (size_t i = 0; i < TONES.size(); ++i) {
std::cout << " " << (i + 1) << ". " << TONES[i] << std::endl;
}
int selection = askQuestionForIntRange(
"Enter a number for an attribute. ",
1, static_cast(TONES.size()));
Aws::SNS::Model::MessageAttributeValue messageAttributeValue;
messageAttributeValue.SetDataType("String");
messageAttributeValue.SetStringValue(TONES[selection - 1]);
request.AddMessageAttributes(TONE_ATTRIBUTE, messageAttributeValue);
}
Aws::SNS::Model::PublishOutcome outcome = snsClient.Publish(request);
if (outcome.IsSuccess()) {
std::cout << "Your message was successfully published." << std::endl;
}
else {
std::cerr << "Error with TopicsAndQueues::Publish. "
<< outcome.GetError().GetMessage()
<< std::endl;
cleanUp(topicARN,
queueURLS,
subscriptionARNS,
snsClient,
sqsClient);
return false;
}
```
+ Pour plus d’informations sur l’API, consultez [Publier](https://docs.aws.amazon.com/goto/SdkForCpp/sns-2010-03-31/Publish) dans *AWS SDK pour C\$1\$1 Référence de l’API*.
------
#### [ CLI ]
**AWS CLI**
**Exemple 1 : pour publier un message dans une rubrique**
L’exemple `publish` suivant publie le message spécifié sur la rubrique SNS spécifiée. Le message provient d’un fichier texte qui vous permet d’inclure des sauts de ligne.
```
aws sns publish \
--topic-arn "arn:aws:sns:us-west-2:123456789012:my-topic" \
--message file://message.txt
```
Contenu de `message.txt` :
```
Hello World
Second Line
```
Sortie :
```
{
"MessageId": "123a45b6-7890-12c3-45d6-111122223333"
}
```
**Exemple 2 : pour publier un SMS sur un numéro de téléphone**
L’exemple `publish` suivant publie le message `Hello world!` sur le numéro de téléphone `+1-555-555-0100`.
```
aws sns publish \
--message "Hello world!" \
--phone-number +1-555-555-0100
```
Sortie :
```
{
"MessageId": "123a45b6-7890-12c3-45d6-333322221111"
}
```
+ Pour plus d’informations sur l’API, consultez [Publish](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/publish.html) dans la *Référence des commandes AWS CLI *.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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
}
// Publish publishes a message to an Amazon SNS topic. The message is then sent to all
// subscribers. When the topic is a FIFO topic, the message must also contain a group ID
// and, when ID-based deduplication is used, a deduplication ID. An optional key-value
// filter attribute can be specified so that the message can be filtered according to
// a filter policy.
func (actor SnsActions) Publish(ctx context.Context, topicArn string, message string, groupId string, dedupId string, filterKey string, filterValue string) error {
publishInput := sns.PublishInput{TopicArn: aws.String(topicArn), Message: aws.String(message)}
if groupId != "" {
publishInput.MessageGroupId = aws.String(groupId)
}
if dedupId != "" {
publishInput.MessageDeduplicationId = aws.String(dedupId)
}
if filterKey != "" && filterValue != "" {
publishInput.MessageAttributes = map[string]types.MessageAttributeValue{
filterKey: {DataType: aws.String("String"), StringValue: aws.String(filterValue)},
}
}
_, err := actor.SnsClient.Publish(ctx, &publishInput)
if err != nil {
log.Printf("Couldn't publish message to topic %v. Here's why: %v", topicArn, err)
}
return err
}
```
+ Pour de plus amples informations sur l’API, consultez [Publier](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sns#Client.Publish) dans *AWS SDK pour Go Référence de l’API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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.PublishRequest;
import software.amazon.awssdk.services.sns.model.PublishResponse;
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 PublishTopic {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
message - The message text to send.
topicArn - The ARN of the topic to publish.
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String message = args[0];
String topicArn = args[1];
SnsClient snsClient = SnsClient.builder()
.region(Region.US_EAST_1)
.build();
pubTopic(snsClient, message, topicArn);
snsClient.close();
}
public static void pubTopic(SnsClient snsClient, String message, String topicArn) {
try {
PublishRequest request = PublishRequest.builder()
.message(message)
.topicArn(topicArn)
.build();
PublishResponse result = snsClient.publish(request);
System.out
.println(result.messageId() + " Message sent. Status is " + result.sdkHttpResponse().statusCode());
} catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ Pour plus d’informations sur l’API, consultez [Publier](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/Publish) dans *AWS SDK for Java 2.x Référence de l’API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
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 { PublishCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string | Record} message - The message to send. Can be a plain string or an object
* if you are using the `json` `MessageStructure`.
* @param {string} topicArn - The ARN of the topic to which you would like to publish.
*/
export const publish = async (
message = "Hello from SNS!",
topicArn = "TOPIC_ARN",
) => {
const response = await snsClient.send(
new PublishCommand({
Message: message,
TopicArn: topicArn,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: 'e7f77526-e295-5325-9ee4-281a43ad1f05',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// MessageId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
// }
return response;
};
```
Publiez un message dans une rubrique avec des options de groupe, de duplication et d’attribut.
```
async publishMessages() {
const message = await this.prompter.input({
message: MESSAGES.publishMessagePrompt,
});
let groupId;
let deduplicationId;
let choices;
if (this.isFifo) {
await this.logger.log(MESSAGES.groupIdNotice);
groupId = await this.prompter.input({
message: MESSAGES.groupIdPrompt,
});
if (this.autoDedup === false) {
await this.logger.log(MESSAGES.deduplicationIdNotice);
deduplicationId = await this.prompter.input({
message: MESSAGES.deduplicationIdPrompt,
});
}
choices = await this.prompter.checkbox({
message: MESSAGES.messageAttributesPrompt,
choices: toneChoices,
});
}
await this.snsClient.send(
new PublishCommand({
TopicArn: this.topicArn,
Message: message,
...(groupId
? {
MessageGroupId: groupId,
}
: {}),
...(deduplicationId
? {
MessageDeduplicationId: deduplicationId,
}
: {}),
...(choices
? {
MessageAttributes: {
tone: {
DataType: "String.Array",
StringValue: JSON.stringify(choices),
},
},
}
: {}),
}),
);
const publishAnother = await this.prompter.confirm({
message: MESSAGES.publishAnother,
});
if (publishAnother) {
await this.publishMessages();
}
}
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-publishing-messages.html).
+ Pour plus d’informations sur l’API, consultez [Publier](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/PublishCommand) dans *AWS SDK pour JavaScript Référence de l’API*.
------
#### [ Kotlin ]
**Kit SDK pour Kotlin**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/sns#code-examples).
```
suspend fun pubTopic(
topicArnVal: String,
messageVal: String,
) {
val request =
PublishRequest {
message = messageVal
topicArn = topicArnVal
}
SnsClient.fromEnvironment { region = "us-east-1" }.use { snsClient ->
val result = snsClient.publish(request)
println("${result.messageId} message sent.")
}
}
```
+ Pour plus d’informations sur l’API, consultez la section [Publier](https://sdk.amazonaws.com/kotlin/api/latest/index.html) de la *référence du kit SDK AWS pour l’API Kotlin*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code 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;
/**
* Sends a message to an Amazon SNS topic.
*
* 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'
]);
$message = 'This message is sent from a Amazon SNS code sample.';
$topic = 'arn:aws:sns:us-east-1:111122223333:MyTopic';
try {
$result = $SnSclient->publish([
'Message' => $message,
'TopicArn' => $topic,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-subscribing-unsubscribing-topics.html#publish-a-message-to-an-sns-topic).
+ Pour plus d’informations sur l’API, consultez [Publier](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Publish) dans *AWS SDK pour PHP Référence de l’API*.
------
#### [ PowerShell ]
**Outils pour PowerShell V4**
**Exemple 1 : Cet exemple montre la publication d'un message avec un seul élément MessageAttribute déclaré en ligne.**
```
Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute @{'City'=[Amazon.SimpleNotificationService.Model.MessageAttributeValue]@{DataType='String'; StringValue ='AnyCity'}}
```
**Exemple 2 : Cet exemple montre la publication d'un message dont plusieurs MessageAttributes ont été déclarés à l'avance.**
```
$cityAttributeValue = New-Object Amazon.SimpleNotificationService.Model.MessageAttributeValue
$cityAttributeValue.DataType = "String"
$cityAttributeValue.StringValue = "AnyCity"
$populationAttributeValue = New-Object Amazon.SimpleNotificationService.Model.MessageAttributeValue
$populationAttributeValue.DataType = "Number"
$populationAttributeValue.StringValue = "1250800"
$messageAttributes = New-Object System.Collections.Hashtable
$messageAttributes.Add("City", $cityAttributeValue)
$messageAttributes.Add("Population", $populationAttributeValue)
Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute $messageAttributes
```
+ Pour plus de détails sur l’API, consultez [Publish](https://docs.aws.amazon.com/powershell/v4/reference) dans la *Référence des applets de commande pour les Outils AWS pour PowerShell (V4)*.
**Outils pour PowerShell V5**
**Exemple 1 : Cet exemple montre la publication d'un message avec un seul élément MessageAttribute déclaré en ligne.**
```
Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute @{'City'=[Amazon.SimpleNotificationService.Model.MessageAttributeValue]@{DataType='String'; StringValue ='AnyCity'}}
```
**Exemple 2 : Cet exemple montre la publication d'un message dont plusieurs MessageAttributes ont été déclarés à l'avance.**
```
$cityAttributeValue = New-Object Amazon.SimpleNotificationService.Model.MessageAttributeValue
$cityAttributeValue.DataType = "String"
$cityAttributeValue.StringValue = "AnyCity"
$populationAttributeValue = New-Object Amazon.SimpleNotificationService.Model.MessageAttributeValue
$populationAttributeValue.DataType = "Number"
$populationAttributeValue.StringValue = "1250800"
$messageAttributes = New-Object System.Collections.Hashtable
$messageAttributes.Add("City", $cityAttributeValue)
$messageAttributes.Add("Population", $populationAttributeValue)
Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute $messageAttributes
```
+ Pour plus de détails sur l’API, consultez [Publish](https://docs.aws.amazon.com/powershell/v5/reference) dans la *Référence des applets de commande pour les Outils AWS pour PowerShell (V5)*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/sns#code-examples).
Publiez un message avec des attributs afin qu’un abonnement puisse filtrer en fonction des attributs.
```
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
@staticmethod
def publish_message(topic, message, attributes):
"""
Publishes a message, with attributes, to a topic. Subscriptions can be filtered
based on message attributes so that a subscription receives messages only
when specified attributes are present.
:param topic: The topic to publish to.
:param message: The message to publish.
:param attributes: The key-value attributes to attach to the message. Values
must be either `str` or `bytes`.
:return: The ID of the message.
"""
try:
att_dict = {}
for key, value in attributes.items():
if isinstance(value, str):
att_dict[key] = {"DataType": "String", "StringValue": value}
elif isinstance(value, bytes):
att_dict[key] = {"DataType": "Binary", "BinaryValue": value}
response = topic.publish(Message=message, MessageAttributes=att_dict)
message_id = response["MessageId"]
logger.info(
"Published message with attributes %s to topic %s.",
attributes,
topic.arn,
)
except ClientError:
logger.exception("Couldn't publish message to topic %s.", topic.arn)
raise
else:
return message_id
```
Publiez un message qui prend différentes formes en fonction du protocole de l’abonné.
```
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
@staticmethod
def publish_multi_message(
topic, subject, default_message, sms_message, email_message
):
"""
Publishes a multi-format message to a topic. A multi-format message takes
different forms based on the protocol of the subscriber. For example,
an SMS subscriber might receive a short version of the message
while an email subscriber could receive a longer version.
:param topic: The topic to publish to.
:param subject: The subject of the message.
:param default_message: The default version of the message. This version is
sent to subscribers that have protocols that are not
otherwise specified in the structured message.
:param sms_message: The version of the message sent to SMS subscribers.
:param email_message: The version of the message sent to email subscribers.
:return: The ID of the message.
"""
try:
message = {
"default": default_message,
"sms": sms_message,
"email": email_message,
}
response = topic.publish(
Message=json.dumps(message), Subject=subject, MessageStructure="json"
)
message_id = response["MessageId"]
logger.info("Published multi-format message to topic %s.", topic.arn)
except ClientError:
logger.exception("Couldn't publish message to topic %s.", topic.arn)
raise
else:
return message_id
```
```
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 publish_message(
self,
topic_arn: str,
message: str,
tone_attribute: Optional[str] = None,
deduplication_id: Optional[str] = None,
message_group_id: Optional[str] = None
) -> str:
"""
Publish a message to an SNS topic.
:param topic_arn: The ARN of the SNS topic.
:param message: The message content to publish.
:param tone_attribute: Optional tone attribute for message filtering.
:param deduplication_id: Optional deduplication ID for FIFO topics.
:param message_group_id: Optional message group ID for FIFO topics.
:return: The message ID of the published message.
:raises ClientError: If the message publication fails.
"""
try:
publish_args = {
'TopicArn': topic_arn,
'Message': message
}
# Add message attributes if tone is specified
if tone_attribute:
publish_args['MessageAttributes'] = {
'tone': {
'DataType': 'String',
'StringValue': tone_attribute
}
}
# Add FIFO-specific parameters
if message_group_id:
publish_args['MessageGroupId'] = message_group_id
if deduplication_id:
publish_args['MessageDeduplicationId'] = deduplication_id
response = self.sns_client.publish(**publish_args)
message_id = response['MessageId']
logger.info(f"Published message to topic {topic_arn} with ID: {message_id}")
return message_id
except ClientError as e:
error_code = e.response.get('Error', {}).get('Code', 'Unknown')
logger.error(f"Error publishing message to topic: {error_code} - {e}")
raise
```
+ Pour plus de détails sur l’API, consultez [Publish](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/Publish) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d'exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/sns#code-examples).
```
# Service class for sending messages using Amazon Simple Notification Service (SNS)
class SnsMessageSender
# Initializes the SnsMessageSender with an SNS client
#
# @param sns_client [Aws::SNS::Client] The SNS client
def initialize(sns_client)
@sns_client = sns_client
@logger = Logger.new($stdout)
end
# Sends a message to a specified SNS topic
#
# @param topic_arn [String] The ARN of the SNS topic
# @param message [String] The message to send
# @return [Boolean] true if message was successfully sent, false otherwise
def send_message(topic_arn, message)
@sns_client.publish(topic_arn: topic_arn, message: message)
@logger.info("Message sent successfully to #{topic_arn}.")
true
rescue Aws::SNS::Errors::ServiceError => e
@logger.error("Error while sending the message: #{e.message}")
false
end
end
# Example usage:
if $PROGRAM_NAME == __FILE__
topic_arn = 'SNS_TOPIC_ARN' # Should be replaced with a real topic ARN
message = 'MESSAGE' # Should be replaced with the actual message content
sns_client = Aws::SNS::Client.new
message_sender = SnsMessageSender.new(sns_client)
@logger.info('Sending message.')
unless message_sender.send_message(topic_arn, message)
@logger.error('Message sending failed. Stopping program.')
exit 1
end
end
```
+ Pour plus d’informations, consultez le [Guide du développeur AWS SDK pour Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/sns-example-send-message.html).
+ Pour de plus amples informations sur l’API, consultez [Publier](https://docs.aws.amazon.com/goto/SdkForRubyV3/sns-2010-03-31/Publish) dans *Référence de l’API AWS SDK pour Ruby *.
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/sns#code-examples).
```
async fn subscribe_and_publish(
client: &Client,
topic_arn: &str,
email_address: &str,
) -> Result<(), Error> {
println!("Receiving on topic with ARN: `{}`", topic_arn);
let rsp = client
.subscribe()
.topic_arn(topic_arn)
.protocol("email")
.endpoint(email_address)
.send()
.await?;
println!("Added a subscription: {:?}", rsp);
let rsp = client
.publish()
.topic_arn(topic_arn)
.message("hello sns!")
.send()
.await?;
println!("Published message: {:?}", rsp);
Ok(())
}
```
+ Pour plus d’informations sur l’API, consultez [Publier](https://docs.rs/aws-sdk-sns/latest/aws_sdk_sns/client/struct.Client.html#method.publish) dans *Référence du kit SDK AWS pour l’API Rust*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/sns#code-examples).
```
TRY.
oo_result = lo_sns->publish( " oo_result is returned for testing purposes. "
iv_topicarn = iv_topic_arn
iv_message = iv_message ).
MESSAGE 'Message published to SNS topic.' TYPE 'I'.
CATCH /aws1/cx_snsnotfoundexception.
MESSAGE 'Topic does not exist.' TYPE 'E'.
ENDTRY.
```
Publiez un message avec les attributs d'un sujet.
```
TRY.
oo_result = lo_sns->publish( " oo_result is returned for testing purposes. "
iv_topicarn = iv_topic_arn
iv_message = iv_message
it_messageattributes = it_msg_attrs ).
MESSAGE 'Message with attributes published to SNS topic.' TYPE 'I'.
CATCH /aws1/cx_snsnotfoundexception.
MESSAGE 'Topic does not exist.' TYPE 'E'.
ENDTRY.
```
Publiez un message multiformat dans un sujet.
```
" Build JSON message structure for multi-format message
DATA(lv_json_message) = |\{ "default": "{ iv_default_message }", "sms": "{ iv_sms_message }", "email": "{ iv_email_message }" \}|.
TRY.
oo_result = lo_sns->publish( " oo_result is returned for testing purposes. "
iv_topicarn = iv_topic_arn
iv_message = lv_json_message
iv_subject = iv_subject
iv_messagestructure = 'json' ).
MESSAGE 'Multi-format message published to SNS topic.' TYPE 'I'.
CATCH /aws1/cx_snsnotfoundexception.
MESSAGE 'Topic does not exist.' TYPE 'E'.
ENDTRY.
```
+ Pour plus de détails sur l’API, consultez [Publish](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) dans la *Référence des API du kit AWS SDK pour SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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.publish(
input: PublishInput(
message: message,
topicArn: arn
)
)
guard let messageId = output.messageId else {
print("No message ID received from Amazon SNS.")
return
}
print("Published message with ID \(messageId)")
```
+ Pour plus de détails sur l’API, consultez [Publish](https://sdk.amazonaws.com/swift/api/awssns/latest/documentation/awssns/snsclient/publish(input:)) dans la *Référence des API du kit AWS SDK pour Swift*.
------
# Publication de messages volumineux avec Amazon SNS et Amazon S3
Pour publier des messages Amazon SNS volumineux, vous pouvez utiliser la [bibliothèque client étendue Amazon SNS pour Java](https://github.com/awslabs/amazon-sns-java-extended-client-lib/) ou la [bibliothèque client étendue Amazon SNS pour Python](https://github.com/awslabs/amazon-sns-python-extended-client-lib). Ces bibliothèques sont utiles pour les messages qui dépassent le maximum actuel de 256 Ko, avec un maximum de 2 Go. Les deux bibliothèques enregistrent la charge utile réelle dans un compartiment Amazon S3 et publient la référence de l'objet Amazon S3 stocké dans la rubrique Amazon SNS. Les files d'attente Amazon SQS abonnées peuvent utiliser la [bibliothèque client étendue Amazon SQS pour Java](https://github.com/awslabs/amazon-sqs-java-extended-client-lib) pour déréférencer et récupérer les charges utiles depuis Amazon S3. D’autres points de terminaison, tels que Lambda, peuvent utiliser la [bibliothèque commune Java de déchargement de la charge utile pour AWS](https://github.com/awslabs/payload-offloading-java-common-lib-for-aws) afin de déréférencer et récupérer la charge utile.
**Note**
Les bibliothèques client étendues Amazon SNS sont compatibles avec les rubriques standard et FIFO.
# Bibliothèque client étendue Amazon SNS pour Java
## Conditions préalables
Voici les prérequis à satisfaire pour utiliser la [bibliothèque client étendue Amazon SNS pour Java](https://github.com/awslabs/amazon-sns-java-extended-client-lib) :
+ Un AWS SDK. L'exemple de cette page utilise le SDK AWS Java. Pour installer et configurer le SDK, consultez la section [Configurer le AWS SDK pour](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-install.html) Java dans le Guide *AWS SDK pour Java du* développeur.
+ Et Compte AWS avec les informations d'identification appropriées. Pour créer un Compte AWS, accédez à la [page d'AWS accueil](https://aws.amazon.com/), puis choisissez **Créer un AWS compte**. Suivez les instructions à l’écran.
Pour plus d'informations sur les informations d'identification, voir [Configurer les AWS informations d'identification et la région pour le développement](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-credentials.html) dans le *guide du AWS SDK pour Java développeur*.
+ Java 8 ou une version ultérieure.
+ Bibliothèque client étendue Amazon SNS pour Java (également disponible à partir de [Maven](https://maven.apache.org/)).
## Configurer le stockage de messages
La bibliothèque Amazon SNS Extended Client utilise la bibliothèque commune Java Payload Offloading AWS pour le stockage et la récupération des messages. Vous pouvez configurer les [options de stockage de messages](https://github.com/awslabs/amazon-sns-java-extended-client-lib/blob/main/src/main/java/software/amazon/sns/SNSExtendedClientConfiguration.java) suivantes pour Amazon S3 :
+ **Seuil de taille de message personnalisé** — Les messages dont la charge utile et les attributs dépassent cette taille sont automatiquement stockés dans Amazon S3.
+ **`alwaysThroughS3`flag** — Définissez cette valeur sur pour `true` forcer le stockage de toutes les charges utiles des messages dans Amazon S3. Par exemple :
```
SNSExtendedClientConfiguration snsExtendedClientConfiguration = new
SNSExtendedClientConfiguration() .withPayloadSupportEnabled(s3Client, BUCKET_NAME).withAlwaysThroughS3(true);
```
+ **Clé KMS personnalisée** : clé à utiliser pour le chiffrement côté serveur dans votre compartiment Amazon S3.
+ **Nom du compartiment** : nom du compartiment Amazon S3 pour stocker les charges utiles des messages.
## Exemple : publication de messages sur Amazon SNS avec la charge utile stockée dans Amazon S3
L’exemple de code suivant illustre comment :
+ Créez un exemple de rubrique et de file d'attente.
+ Abonnez la file d'attente pour recevoir des messages de la rubrique.
+ Publiez un message de test.
La charge utile du message est stockée dans Amazon S3 et sa référence est publiée. Le client étendu Amazon SQS est utilisé pour recevoir le message.
**Kit SDK pour Java 1.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/java/example_code/sns#code-examples).
Pour publier un message volumineux, vous pouvez utiliser la bibliothèque client étendue Amazon SNS pour Java. Le message que vous envoyez fait référence à un objet Amazon S3 contenant le contenu réel du message.
```
import com.amazon.sqs.javamessaging.AmazonSQSExtendedClient;
import com.amazon.sqs.javamessaging.ExtendedClientConfiguration;
import com.amazonaws.regions.Region;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.sns.AmazonSNS;
import com.amazonaws.services.sns.AmazonSNSClientBuilder;
import com.amazonaws.services.sns.model.CreateTopicRequest;
import com.amazonaws.services.sns.model.PublishRequest;
import com.amazonaws.services.sns.model.SetSubscriptionAttributesRequest;
import com.amazonaws.services.sns.util.Topics;
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.CreateQueueRequest;
import com.amazonaws.services.sqs.model.ReceiveMessageResult;
import software.amazon.sns.AmazonSNSExtendedClient;
import software.amazon.sns.SNSExtendedClientConfiguration;
public class Example {
public static void main(String[] args) {
final String BUCKET_NAME = "extended-client-bucket";
final String TOPIC_NAME = "extended-client-topic";
final String QUEUE_NAME = "extended-client-queue";
final Regions region = Regions.DEFAULT_REGION;
// Message threshold controls the maximum message size that will be allowed to
// be published
// through SNS using the extended client. Payload of messages exceeding this
// value will be stored in
// S3. The default value of this parameter is 256 KB which is the maximum
// message size in SNS (and SQS).
final int EXTENDED_STORAGE_MESSAGE_SIZE_THRESHOLD = 32;
// Initialize SNS, SQS and S3 clients
final AmazonSNS snsClient = AmazonSNSClientBuilder.standard().withRegion(region).build();
final AmazonSQS sqsClient = AmazonSQSClientBuilder.standard().withRegion(region).build();
final AmazonS3 s3Client = AmazonS3ClientBuilder.standard().withRegion(region).build();
// Create bucket, topic, queue and subscription
s3Client.createBucket(BUCKET_NAME);
final String topicArn = snsClient.createTopic(
new CreateTopicRequest().withName(TOPIC_NAME)).getTopicArn();
final String queueUrl = sqsClient.createQueue(
new CreateQueueRequest().withQueueName(QUEUE_NAME)).getQueueUrl();
final String subscriptionArn = Topics.subscribeQueue(
snsClient, sqsClient, topicArn, queueUrl);
// To read message content stored in S3 transparently through SQS extended
// client,
// set the RawMessageDelivery subscription attribute to TRUE
final SetSubscriptionAttributesRequest subscriptionAttributesRequest = new SetSubscriptionAttributesRequest();
subscriptionAttributesRequest.setSubscriptionArn(subscriptionArn);
subscriptionAttributesRequest.setAttributeName("RawMessageDelivery");
subscriptionAttributesRequest.setAttributeValue("TRUE");
snsClient.setSubscriptionAttributes(subscriptionAttributesRequest);
// Initialize SNS extended client
// PayloadSizeThreshold triggers message content storage in S3 when the
// threshold is exceeded
// To store all messages content in S3, use AlwaysThroughS3 flag
final SNSExtendedClientConfiguration snsExtendedClientConfiguration = new SNSExtendedClientConfiguration()
.withPayloadSupportEnabled(s3Client, BUCKET_NAME)
.withPayloadSizeThreshold(EXTENDED_STORAGE_MESSAGE_SIZE_THRESHOLD);
final AmazonSNSExtendedClient snsExtendedClient = new AmazonSNSExtendedClient(snsClient,
snsExtendedClientConfiguration);
// Publish message via SNS with storage in S3
final String message = "This message is stored in S3 as it exceeds the threshold of 32 bytes set above.";
snsExtendedClient.publish(topicArn, message);
// Initialize SQS extended client
final ExtendedClientConfiguration sqsExtendedClientConfiguration = new ExtendedClientConfiguration()
.withPayloadSupportEnabled(s3Client, BUCKET_NAME);
final AmazonSQSExtendedClient sqsExtendedClient = new AmazonSQSExtendedClient(sqsClient,
sqsExtendedClientConfiguration);
// Read the message from the queue
final ReceiveMessageResult result = sqsExtendedClient.receiveMessage(queueUrl);
System.out.println("Received message is " + result.getMessages().get(0).getBody());
}
}
```
## Autres protocoles de point de terminaison
Les bibliothèques Amazon SNS et Amazon SQS utilisent la [bibliothèque commune Java de déchargement de la charge utile pour AWS](https://github.com/awslabs/payload-offloading-java-common-lib-for-aws) pour stocker et récupérer les charges utiles des messages avec Amazon S3. Tout point de terminaison compatible Java (par exemple, un point de terminaison HTTPS implémenté en Java) peut utiliser la même bibliothèque pour déréférencer le contenu du message.
Les points de terminaison qui ne peuvent pas utiliser la bibliothèque commune Java de déchargement de charge utile AWS peuvent toujours publier des messages avec des charges utiles stockées dans Amazon S3. Voici un exemple de référence Amazon S3 qui est publiée par l'exemple de code ci-dessus :
```
[
"software.amazon.payloadoffloading.PayloadS3Pointer",
{
"s3BucketName": "extended-client-bucket",
"s3Key": "xxxx-xxxxx-xxxxx-xxxxxx"
}
]
```
# Bibliothèque client étendue Amazon SNS pour Python
## Conditions préalables
Voici les prérequis à satisfaire pour utiliser la [bibliothèque client étendue Amazon SNS pour Python](https://github.com/awslabs/amazon-sns-python-extended-client-lib) :
+ Un AWS SDK. L'exemple de cette page utilise le SDK AWS Python Boto3. Pour installer et configurer le kit SDK, consultez la documentation [https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html).
+ Et Compte AWS avec les informations d'identification appropriées. Pour créer un Compte AWS, accédez à la [page d'AWS accueil](https://aws.amazon.com/), puis choisissez **Créer un AWS compte**. Suivez les instructions à l’écran.
Pour obtenir des informations sur les informations d'identification, consultez [Informations d'identification](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) dans le *Guide du développeur AWS SDK pour Python*.
+ Python 3.x (ou version ultérieure) et pip.
+ Bibliothèque client étendue Amazon SNS pour Python (également disponible à partir de [PyPI](https://pypi.org/project/amazon-sns-extended-client/)).
## Configurer le stockage de messages
Les attributs ci-dessous sont disponibles sur Boto3 Amazon [SNS](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#client) Client[,](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns/topic/index.html) Topic [PlatformEndpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns/platformendpoint/index.html)et Objects pour configurer les options de stockage des messages Amazon S3.
+ **`large_payload_support`**— Le nom du compartiment Amazon S3 qui stockera les messages volumineux.
+ **`use_legacy_attribute`**— Dans `True` ce cas, tous les messages publiés utilisent l'attribut de message réservé Legacy (`SQSLargePayloadSize`) au lieu de l'attribut de message réservé actuel (`ExtendedPayloadSize`).
+ **`message_size_threshold`** – Seuil de stockage du message dans le compartiment de messages volumineux. Ne peut pas être inférieur `0` ou supérieur à`262144`. La valeur par défaut est `262144`.
+ **`always_through_s3`** – Si la valeur est `True`, tous les messages sont stockés dans Amazon S3. La valeur par défaut est `False`.
+ **`s3_client`**— L'`client`objet Boto3 Amazon S3 à utiliser pour stocker des objets sur Amazon S3. Utilisez-le si vous souhaitez contrôler le client Amazon S3 (par exemple, configuration Amazon S3 personnalisée ou informations d'identification). La valeur par défaut est utilisée `boto3.client("s3")` lors de la première utilisation si ce n'est pas déjà le cas.
## Exemple : publication de messages dans Amazon SNS avec la charge utile stockée dans Amazon S3
L’exemple de code suivant illustre comment :
+ Créez un exemple de rubrique Amazon SNS et de file d'attente Amazon SQS.
+ Joignez la politique à la file d'attente Amazon SQS pour recevoir le message de la rubrique Amazon SNS.
+ Abonnez la file d'attente pour recevoir des messages de la rubrique.
+ Publiez un message de test à l'aide du client étendu Amazon SNS, de la ressource Topic et PlatformEndpoint de la ressource.
+ La charge utile du message est stockée dans Amazon S3 et sa référence est publiée.
+ Imprimer le message publié depuis la file d'attente avec le message d'origine extrait d'Amazon S3.
Pour publier un message volumineux, vous pouvez utiliser la bibliothèque client étendue Amazon SNS pour Python. Le message que vous envoyez fait référence à un objet Amazon S3 contenant le contenu réel du message.
```
import boto3
from sns_extended_client import SNSExtendedClientSession
from json import loads
s3_extended_payload_bucket = "extended-client-bucket-store" # S3 bucket with the given bucket name is a resource which is created and accessible with the given AWS credentials
TOPIC_NAME = "---TOPIC-NAME---"
QUEUE_NAME = "---QUEUE-NAME---"
def allow_sns_to_write_to_sqs(topicarn, queuearn):
policy_document = """{{
"Version": "2012-10-17",
"Statement":[
{{
"Sid":"MyPolicy",
"Effect":"Allow",
"Principal" : {{"AWS" : "*"}},
"Action":"SQS:SendMessage",
"Resource": "{}",
"Condition":{{
"ArnEquals":{{
"aws:SourceArn": "{}"
}}
}}
}}
]
}}""".format(queuearn, topicarn)
return policy_document
def get_msg_from_s3(body,sns_extended_client):
"""Handy Helper to fetch message from S3"""
json_msg = loads(body)
s3_object = sns_extended_client.s3_client.get_object(
Bucket=json_msg[1].get("s3BucketName"), Key=json_msg[1].get("s3Key")
)
msg = s3_object.get("Body").read().decode()
return msg
def fetch_and_print_from_sqs(sqs, queue_url,sns_extended_client):
sqs_msg = sqs.receive_message(
QueueUrl=queue_url,
AttributeNames=['All'],
MessageAttributeNames=['All'],
VisibilityTimeout=0,
WaitTimeSeconds=0,
MaxNumberOfMessages=1
).get("Messages")[0]
message_body = sqs_msg.get("Body")
print("Published Message: {}".format(message_body))
print("Message Stored in S3 Bucket is: {}\n".format(get_msg_from_s3(message_body,sns_extended_client)))
# Delete the Processed Message
sqs.delete_message(
QueueUrl=queue_url,
ReceiptHandle=sqs_msg['ReceiptHandle']
)
sns_extended_client = boto3.client("sns", region_name="us-east-1")
create_topic_response = sns_extended_client.create_topic(Name=TOPIC_NAME)
sns_topic_arn = create_topic_response.get("TopicArn")
# create and subscribe an sqs queue to the sns client
sqs = boto3.client("sqs",region_name="us-east-1")
demo_queue_url = sqs.create_queue(QueueName=QUEUE_NAME).get("QueueUrl")
sqs_queue_arn = sqs.get_queue_attributes(
QueueUrl=demo_queue_url, AttributeNames=["QueueArn"]
)["Attributes"].get("QueueArn")
# Adding policy to SQS queue such that SNS topic can send msg to SQS queue
policy_json = allow_sns_to_write_to_sqs(sns_topic_arn, sqs_queue_arn)
response = sqs.set_queue_attributes(
QueueUrl = demo_queue_url,
Attributes = {
'Policy' : policy_json
}
)
# Set the RawMessageDelivery subscription attribute to TRUE if you want to use
# SQSExtendedClient to help with retrieving msg from S3
sns_extended_client.subscribe(TopicArn=sns_topic_arn, Protocol="sqs",
Endpoint=sqs_queue_arn
, Attributes={"RawMessageDelivery":"true"}
)
sns_extended_client.large_payload_support = s3_extended_payload_bucket
# Change default s3_client attribute of sns_extended_client to use 'us-east-1' region
sns_extended_client.s3_client = boto3.client("s3", region_name="us-east-1")
# Below is the example that all the messages will be sent to the S3 bucket
sns_extended_client.always_through_s3 = True
sns_extended_client.publish(
TopicArn=sns_topic_arn, Message="This message should be published to S3"
)
print("\n\nPublished using SNS extended client:")
fetch_and_print_from_sqs(sqs, demo_queue_url,sns_extended_client) # Prints message stored in s3
# Below is the example that all the messages larger than 32 bytes will be sent to the S3 bucket
print("\nUsing decreased message size threshold:")
sns_extended_client.always_through_s3 = False
sns_extended_client.message_size_threshold = 32
sns_extended_client.publish(
TopicArn=sns_topic_arn,
Message="This message should be published to S3 as it exceeds the limit of the 32 bytes",
)
fetch_and_print_from_sqs(sqs, demo_queue_url,sns_extended_client) # Prints message stored in s3
# Below is the example to publish message using the SNS.Topic resource
sns_extended_client_resource = SNSExtendedClientSession().resource(
"sns", region_name="us-east-1"
)
topic = sns_extended_client_resource.Topic(sns_topic_arn)
topic.large_payload_support = s3_extended_payload_bucket
# Change default s3_client attribute of topic to use 'us-east-1' region
topic.s3_client = boto3.client("s3", region_name="us-east-1")
topic.always_through_s3 = True
# Can Set custom S3 Keys to be used to store objects in S3
topic.publish(
Message="This message should be published to S3 using the topic resource",
MessageAttributes={
"S3Key": {
"DataType": "String",
"StringValue": "347c11c4-a22c-42e4-a6a2-9b5af5b76587",
}
},
)
print("\nPublished using Topic Resource:")
fetch_and_print_from_sqs(sqs, demo_queue_url,topic)
# Below is the example to publish message using the SNS.PlatformEndpoint resource
sns_extended_client_resource = SNSExtendedClientSession().resource(
"sns", region_name="us-east-1"
)
platform_endpoint = sns_extended_client_resource.PlatformEndpoint(sns_topic_arn)
platform_endpoint.large_payload_support = s3_extended_payload_bucket
# Change default s3_client attribute of platform_endpoint to use 'us-east-1' region
platform_endpoint.s3_client = boto3.client("s3", region_name="us-east-1")
platform_endpoint.always_through_s3 = True
# Can Set custom S3 Keys to be used to store objects in S3
platform_endpoint.publish(
Message="This message should be published to S3 using the PlatformEndpoint resource",
MessageAttributes={
"S3Key": {
"DataType": "String",
"StringValue": "247c11c4-a22c-42e4-a6a2-9b5af5b76587",
}
},
)
print("\nPublished using PlatformEndpoint Resource:")
fetch_and_print_from_sqs(sqs, demo_queue_url,platform_endpoint)
```
**Sortie**
```
Published using SNS extended client:
Published Message: ["software.amazon.payloadoffloading.PayloadS3Pointer", {"s3BucketName": "extended-client-bucket-store", "s3Key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}]
Message Stored in S3 Bucket is: This message should be published to S3
Using decreased message size threshold:
Published Message: ["software.amazon.payloadoffloading.PayloadS3Pointer", {"s3BucketName": "extended-client-bucket-store", "s3Key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}]
Message Stored in S3 Bucket is: This message should be published to S3 as it exceeds the limit of the 32 bytes
Published using Topic Resource:
Published Message: ["software.amazon.payloadoffloading.PayloadS3Pointer", {"s3BucketName": "extended-client-bucket-store", "s3Key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}]
Message Stored in S3 Bucket is: This message should be published to S3 using the topic resource
Published using PlatformEndpoint Resource:
Published Message: ["software.amazon.payloadoffloading.PayloadS3Pointer", {"s3BucketName": "extended-client-bucket-store", "s3Key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}]
Message Stored in S3 Bucket is: This message should be published to S3 using the PlatformEndpoint resource
```
# Attributs de message Amazon SNS
Amazon SNS prend en charge la distribution des attributs de message qui vous permettent de fournir des éléments de métadonnées structurés (tels que des horodatages, des données géospatiales, des signatures et des identifiants) sur le message. Pour les abonnements SQS, un maximum de 10 attributs de message peuvent être envoyés lorsque la [remise des messages bruts](sns-large-payload-raw-message-delivery.md) est activée. Pour envoyer plus de 10 attributs de message, la remise des messages bruts doit être désactivée. Les messages comportant plus de 10 attributs de message dirigés vers des abonnements Amazon SQS ayant le paramètre Diffusion brute des messages activé sont supprimés en tant qu'erreurs côté client.
Les attributs de message sont facultatifs et séparés du corps du message, bien qu'ils soient envoyés en même temps. Le récepteur peut utiliser ces informations pour traiter le message sans avoir à traiter le corps du message en premier.
Pour plus d'informations sur l'envoi de messages avec des attributs à l'aide du AWS Management Console ou du AWS SDK pour Java, consultez le [Pour publier des messages sur des rubriques Amazon SNS à l'aide du AWS Management Console](sns-publishing.md#sns-publishing-messages) didacticiel.
**Note**
Les attributs de message sont envoyés uniquement lorsque la structure du message est Chaîne et non JSON.
Vous pouvez également utiliser les attributs de message pour mieux structurer le message de notification push pour les points de terminaison mobiles. Dans ce scénario, les attributs du message sont uniquement utilisés pour vous aider à structurer le message de notification push. Les attributs ne sont pas distribués au point de terminaison, comme c'est le cas lors de l'envoi de messages avec les attributs du message aux points de terminaison Amazon SQS.
Vous pouvez également utiliser les attributs du message pour que vos messages puissent être filtrés à l'aide de stratégies de filtre d'abonnement. Vous pouvez appliquer des stratégies de filtre aux abonnements aux rubriques. Lorsqu'une politique de filtre est appliquée avec une étendue de politique de filtre définie sur `MessageAttributes` (par défaut), un abonnement reçoit uniquement les messages ayant des attributs acceptés par la politique. Pour de plus amples informations, veuillez consulter [Filtrage des messages Amazon SNS](sns-message-filtering.md).
**Note**
Lorsque des attributs de message sont utilisés pour le filtrage, la valeur doit être une chaîne JSON valide. Cela garantit que le message est remis à un abonnement avec le filtrage des attributs de message activé.
## Éléments d'attribut de message et validation
Chaque attribut de message se compose des éléments suivants :
+ **Name** – Le nom d'attribut de message peut contenir les caractères suivants : A-Z, a-z, 0-9, trait de soulignement (\$1), tiret (-) et point (.). Le nom ne doit pas commencer ou se terminer par un point et ne doit pas contenir plusieurs points à la suite. Le nom est sensible à la casse et doit être unique parmi tous les noms d'attribut pour le message. La longueur maximale du nom est de 256 caractères. Le nom ne peut pas commencer par `AWS.` ou `Amazon.` (indépendamment de la casse), car ces préfixes sont réservés pour une utilisation par Amazon Web Services.
+ **Type** – Les types de données d'attribut de message pris en charge sont `String`, `String.Array`, `Number` et `Binary`. Le type de données est soumis aux mêmes restrictions de contenu que le corps du message. Pour plus d’informations, consultez la section [Types de données d'attribut de message et validation](#SNSMessageAttributes.DataTypes).
+ **Value** – La valeur d'attribut du message spécifiée par l'utilisateur. Pour les types de données de type chaîne, l'attribut value doit respecter les mêmes restrictions de contenu que le corps du message. Toutefois, si l'attribut de message est utilisé pour le filtrage, la valeur doit être une chaîne JSON valide pour garantir la compatibilité avec les politiques de filtrage des abonnements Amazon SNS. Pour plus d'informations, consultez [Publish](https://docs.aws.amazon.com/sns/latest/api/API_Publish.html) dans la *Référence d'API Amazon Simple Notification Service*.
Les nom, type et valeur ne doivent pas être vides ni contenir la valeur null. Le corps du message ne doit pas être vide ni contenir la valeur null non plus. Toutes les parties de l'attribut du message, y compris le nom, le type et la valeur, sont incluses dans la restriction de taille du message, qui est de 256 Ko.
## Types de données d'attribut de message et validation
Les types de données d'attribut de message identifient la façon dont les valeurs d'attribut de message sont traitées par Amazon SNS. Par exemple, si le type est un nombre, Amazon SNS valide le fait qu'il s'agit d'un nombre.
Amazon SNS prend en charge les types de données logiques suivants pour tous les points de terminaison, sauf indication contraire :
+ **String** – Les chaînes sont au format Unicode avec un codage binaire UTF-8. Pour obtenir la liste des valeurs de code, consultez [http://en.wikipedia. org/wiki/ASCII](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters)\$1ASCII\$1printable\$1characters.
**Note**
Les valeurs de substitution ne sont pas prises en charge dans les attributs du message. Par exemple, l’utilisation d’une valeur de substitution pour représenter un emoji vous donnera l’erreur suivante :`Invalid attribute value was passed in for message attribute`.
+ **String.Array** – Tableau, formaté sous la forme d'une chaîne, qui peut contenir plusieurs valeurs. Les valeurs peuvent être des chaînes, des nombres ou les mots-clés `true`, `false` et `null`. Un String.Array de type nombre ou booléen ne nécessite pas de guillemets. Les valeurs String.Array multiples sont séparées par des virgules.
Ce type de données n'est pas pris en charge pour les AWS Lambda abonnements. Si vous spécifiez ce type de données pour les points de terminaison Lambda, il est transmis comme type de données `String` dans la charge utile JSON qu'Amazon SNS distribue à Lambda.
+ **Number** – Les nombres sont des entiers positifs ou négatifs, ou des nombres à virgule flottante. La plage et la précision des nombres sont suffisantes pour englober la plupart des valeurs qui peuvent généralement être prises en charge par les entiers, les nombres flottants et les doubles. Un nombre peut avoir une valeur de -109 à 109, avec une précision de 5 chiffres après la virgule. Les zéros de début et de fin sont tronqués.
Ce type de données n'est pas pris en charge pour les AWS Lambda abonnements. Si vous spécifiez ce type de données pour les points de terminaison Lambda, il est transmis comme type de données `String` dans la charge utile JSON qu'Amazon SNS distribue à Lambda.
+ **Binary** – Les attributs de type binaire peuvent stocker n'importe quelle donnée binaire, notamment des données compressées, des données chiffrées ou des images.
## Attributs de message réservés pour les notifications push mobiles
Le tableau suivant répertorie les attributs de message réservés pour les services de notification push mobiles que vous pouvez utiliser pour structurer votre message de notification push :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sns/latest/dg/sns-message-attributes.html)
1 Apple rejettera les notifications Amazon SNS si les attributs de message ne répondent pas à ses exigences. Pour plus de détails, consultez la section [Envoi de demandes de notification APNs](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/sending_notification_requests_to_apns) sur le site Web des développeurs Apple.
# Traitement par lots de messages Amazon SNS
## Qu'est-ce que le traitement par lots de messages ?
Une alternative à la publication de messages sur des rubriques Standard ou FIFO dans des demandes d’API `Publish` individuelles, consiste à utiliser l’API `PublishBatch` Amazon SNS permettant de publier jusqu'à 10 messages dans une seule demande d'API. L'envoi de messages par lots peut vous aider à réduire les coûts associés à la connexion d'applications distribuées ([Messagerie A2A](sns-system-to-system-messaging.md)) ou en envoyant des notifications à des personnes ([Messagerie A2P](sns-user-notifications.md)) avec Amazon SNS selon un facteur de 10 maximum. Amazon SNS dispose de quotas sur le nombre de messages que vous pouvez publier sur une rubrique par seconde en fonction de la région dans laquelle vous opérez. Consultez la page [Points de terminaison et quotas Amazon SNS](https://docs.aws.amazon.com/general/latest/gr/sns.html) du guide *Références générales AWS* pour en savoir plus sur les quotas d'API.
**Note**
La taille globale totale de tous les messages que vous envoyez dans le cadre d'une seule demande d'`PublishBatch`API ne peut pas dépasser 262 144 octets (256 KiB).
L’API `PublishBatch` utilise la même action d’API `Publish` pour les politiques IAM.
## Comment fonctionne le traitement par lots de messages ?
La publication de messages avec l’API `PublishBatch` est similaire à la publication de messages avec l’API `Publish`. La principale différence réside dans le fait qu’un ID de lot unique doit être attribué à chaque message d'une demande d’API `PublishBatch` (jusqu'à 80 caractères). De cette façon, Amazon SNS peut renvoyer des réponses d’API individuelles pour chaque message d'un lot pour confirmer que chaque message a été publié ou qu'un échec s'est produit. Pour les messages publiés sur des rubriques FIFO, en plus de l’ajout de l'attribution d'un ID de lot unique, vous devez toujours inclure un `MessageDeduplicationID` et `MessageGroupId` pour chaque message individuel.
## Exemples
**Publication d'un lot de 10 messages sur une rubrique Standard**
```
// Imports
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.PublishBatchRequest;
import software.amazon.awssdk.services.sns.model.PublishBatchRequestEntry;
import software.amazon.awssdk.services.sns.model.PublishBatchResponse;
import software.amazon.awssdk.services.sns.model.SnsException;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
// Code
private static final int MAX_BATCH_SIZE = 10;
public static void publishBatchToTopic(SnsClient snsClient, String topicArn, int batchSize) {
try {
// Validate the batch size
if (batchSize > MAX_BATCH_SIZE) {
throw new IllegalArgumentException("Batch size cannot exceed " + MAX_BATCH_SIZE);
}
// Create the batch entries
List entries = IntStream.range(0, batchSize)
.mapToObj(i -> PublishBatchRequestEntry.builder()
.id("id" + i)
.message("message" + i)
.build())
.collect(Collectors.toList());
// Build the batch request
PublishBatchRequest request = PublishBatchRequest.builder()
.topicArn(topicArn)
.publishBatchRequestEntries(entries)
.build();
// Publish the batch request
PublishBatchResponse response = snsClient.publishBatch(request);
// Handle successful messages
response.successful().forEach(success -> {
System.out.println("Successful Batch Id: " + success.id());
System.out.println("Message Id: " + success.messageId());
});
// Handle failed messages
response.failed().forEach(failure -> {
System.err.println("Failed Batch Id: " + failure.id());
System.err.println("Error Code: " + failure.code());
System.err.println("Sender Fault: " + failure.senderFault());
System.err.println("Error Message: " + failure.message());
});
} catch (SnsException e) {
// Log and handle exceptions
System.err.println("SNS Exception: " + e.awsErrorDetails().errorMessage());
} catch (IllegalArgumentException e) {
System.err.println("Validation Error: " + e.getMessage());
}
}
```
**Publication d'un lot de 10 messages sur une rubrique FIFO**
```
// Imports
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.PublishBatchRequest;
import software.amazon.awssdk.services.sns.model.PublishBatchRequestEntry;
import software.amazon.awssdk.services.sns.model.PublishBatchResponse;
import software.amazon.awssdk.services.sns.model.BatchResultErrorEntry;
import software.amazon.awssdk.services.sns.model.SnsException;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
// Code
private static final int MAX_BATCH_SIZE = 10;
public static void publishBatchToFifoTopic(SnsClient snsClient, String topicArn) {
try {
// Create the batch entries to send
List entries = IntStream.range(0, MAX_BATCH_SIZE)
.mapToObj(i -> PublishBatchRequestEntry.builder()
.id("id" + i)
.message("message" + i)
.messageGroupId("groupId")
.messageDeduplicationId("deduplicationId" + i)
.build())
.collect(Collectors.toList());
// Create the batch request
PublishBatchRequest request = PublishBatchRequest.builder()
.topicArn(topicArn)
.publishBatchRequestEntries(entries)
.build();
// Publish the batch request
PublishBatchResponse response = snsClient.publishBatch(request);
// Handle the successfully sent messages
response.successful().forEach(success -> {
System.out.println("Batch Id for successful message: " + success.id());
System.out.println("Message Id for successful message: " + success.messageId());
System.out.println("Sequence Number for successful message: " + success.sequenceNumber());
});
// Handle the failed messages
response.failed().forEach(failure -> {
System.err.println("Batch Id for failed message: " + failure.id());
System.err.println("Error Code for failed message: " + failure.code());
System.err.println("Sender Fault for failed message: " + failure.senderFault());
System.err.println("Failure Message for failed message: " + failure.message());
});
} catch (SnsException e) {
// Handle any exceptions from the request
System.err.println("SNS Exception: " + e.awsErrorDetails().errorMessage());
}
}
```
# Supprimer un sujet et un abonnement Amazon SNS
Lorsqu'un sujet est supprimé, les abonnements qui lui sont associés sont supprimés de manière asynchrone. Bien que les clients puissent toujours accéder à ces abonnements, ceux-ci ne sont plus associés au sujet, même si vous recréez le sujet sous le même nom. Si un éditeur tente de publier un message sur le sujet supprimé, il recevra un message d'erreur indiquant que le sujet n'existe pas. De même, toute tentative d'abonnement à la rubrique supprimée se traduira par un message d'erreur. Vous ne pouvez pas supprimer un abonnement qui est en attente de confirmation. Amazon SNS supprime automatiquement les abonnements non confirmés au bout de 48 heures, à l'exception des abonnements par e-mail, qui sont supprimés au bout de 30 jours.
**Important**
Les rubriques Amazon SNS supprimées ne peuvent pas être récupérées. Nous vous recommandons de supprimer les abonnements avant de supprimer un sujet.
Une fois l'abonnement supprimé, il ne peut pas être récupéré. Les notifications publiées sur la rubrique Amazon SNS ne seront pas envoyées à cet abonnement supprimé. Vous devrez recréer l'abonnement pour recevoir des notifications.
## Pour supprimer un sujet ou un abonnement Amazon SNS à l'aide du AWS Management Console
La suppression d'une rubrique ou d'un abonnement Amazon SNS garantit une gestion efficace des ressources, empêche toute utilisation inutile et permet d'organiser la console Amazon SNS. Cette étape permet d'éviter les coûts potentiels liés aux ressources inutilisées et de rationaliser l'administration en supprimant les sujets ou les abonnements qui ne sont plus nécessaires.
**Pour supprimer un sujet à l'aide du AWS Management Console**
1. Connectez-vous à la [console Amazon SNS](https://console.aws.amazon.com/sns/home).
1. Dans le panneau de navigation de gauche, choisissez **Rubriques**.
1. Sur la page **Rubriques**, sélectionnez une rubrique puis choisissez **Supprimer**.
1. Dans la boîte de dialogue **Supprimer la rubrique**, saisissez `delete me`, puis choisissez **Supprimer**.
La console supprime la rubrique.
**Pour supprimer un abonnement à l'aide du AWS Management Console**
1. Connectez-vous à la [console Amazon SNS](https://console.aws.amazon.com/sns/home).
1. Dans le volet de navigation de gauche, choisissez **Subscriptions (Abonnements)**.
1. Sur la page **Abonnements**, sélectionnez un abonnement dont le statut est **Confirmé**, puis choisissez **Supprimer**.
1. Dans la boîte de dialogue **Supprimer l'abonnement**, sélectionnez **Supprimer**.
La console supprime l'abonnement.
## Pour supprimer un abonnement et 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](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) dans le *guide de référence des outils AWS SDKs et des outils*.
Les exemples de code suivants illustrent comment utiliser `DeleteTopic`.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/TopicsAndQueues#code-examples).
Supprimez une rubrique à l’aide de son ARN de rubrique.
```
///
/// Delete a topic by its topic ARN.
///
/// The ARN of the topic.
/// True if successful.
public async Task DeleteTopicByArn(string topicArn)
{
var deleteResponse = await _amazonSNSClient.DeleteTopicAsync(
new DeleteTopicRequest()
{
TopicArn = topicArn
});
return deleteResponse.HttpStatusCode == HttpStatusCode.OK;
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTopic](https://docs.aws.amazon.com/goto/DotNetSDKV3/sns-2010-03-31/DeleteTopic)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sns#code-examples).
```
//! Delete an Amazon Simple Notification Service (Amazon SNS) topic.
/*!
\param topicARN: The Amazon Resource Name (ARN) for an Amazon SNS topic.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SNS::deleteTopic(const Aws::String &topicARN,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SNS::SNSClient snsClient(clientConfiguration);
Aws::SNS::Model::DeleteTopicRequest request;
request.SetTopicArn(topicARN);
const Aws::SNS::Model::DeleteTopicOutcome outcome = snsClient.DeleteTopic(request);
if (outcome.IsSuccess()) {
std::cout << "Successfully deleted the Amazon SNS topic " << topicARN << std::endl;
}
else {
std::cerr << "Error deleting topic " << topicARN << ":" <<
outcome.GetError().GetMessage() << std::endl;
}
return outcome.IsSuccess();
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTopic](https://docs.aws.amazon.com/goto/SdkForCpp/sns-2010-03-31/DeleteTopic)à la section *Référence des AWS SDK pour C\$1\$1 API*.
------
#### [ CLI ]
**AWS CLI**
**Pour supprimer une rubrique SNS**
L’exemple `delete-topic` suivant supprime la rubrique SNS spécifiée.
```
aws sns delete-topic \
--topic-arn "arn:aws:sns:us-west-2:123456789012:my-topic"
```
Cette commande ne produit aucune sortie.
+ Pour plus de détails sur l'API, reportez-vous [DeleteTopic](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/delete-topic.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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
}
// DeleteTopic delete an Amazon SNS topic.
func (actor SnsActions) DeleteTopic(ctx context.Context, topicArn string) error {
_, err := actor.SnsClient.DeleteTopic(ctx, &sns.DeleteTopicInput{
TopicArn: aws.String(topicArn)})
if err != nil {
log.Printf("Couldn't delete topic %v. Here's why: %v\n", topicArn, err)
}
return err
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTopic](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sns#Client.DeleteTopic)à la section *Référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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.DeleteTopicRequest;
import software.amazon.awssdk.services.sns.model.DeleteTopicResponse;
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 DeleteTopic {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
topicArn - The ARN of the topic to delete.
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String topicArn = args[0];
SnsClient snsClient = SnsClient.builder()
.region(Region.US_EAST_1)
.build();
System.out.println("Deleting a topic with name: " + topicArn);
deleteSNSTopic(snsClient, topicArn);
snsClient.close();
}
public static void deleteSNSTopic(SnsClient snsClient, String topicArn) {
try {
DeleteTopicRequest request = DeleteTopicRequest.builder()
.topicArn(topicArn)
.build();
DeleteTopicResponse result = snsClient.deleteTopic(request);
System.out.println("\n\nStatus was " + result.sdkHttpResponse().statusCode());
} catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTopic](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/DeleteTopic)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l'exemple complet et découvrez comment le configurer et l'exécuter dans le [ référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples).
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 { DeleteTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string} topicArn - The ARN of the topic to delete.
*/
export const deleteTopic = async (topicArn = "TOPIC_ARN") => {
const response = await snsClient.send(
new DeleteTopicCommand({ TopicArn: topicArn }),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: 'a10e2886-5a8f-5114-af36-75bd39498332',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// }
// }
};
```
+ Pour plus d’informations, consultez le [AWS SDK pour JavaScript Guide du développeur](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topics-deletetopic).
+ Pour plus de détails sur l'API, reportez-vous [DeleteTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/DeleteTopicCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/sns#code-examples).
```
suspend fun deleteSNSTopic(topicArnVal: String) {
val request =
DeleteTopicRequest {
topicArn = topicArnVal
}
SnsClient.fromEnvironment { region = "us-east-1" }.use { snsClient ->
snsClient.deleteTopic(request)
println("$topicArnVal was successfully deleted.")
}
}
```
+ Pour plus de détails sur l'API, consultez [DeleteTopic](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la section *AWS SDK pour la référence de l'API Kotlin*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
/**
* Deletes an SNS topic and all its subscriptions.
*
* 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'
]);
$topic = 'arn:aws:sns:us-east-1:111122223333:MyTopic';
try {
$result = $SnSclient->deleteTopic([
'TopicArn' => $topic,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/DeleteTopic)à la section *Référence des AWS SDK pour PHP API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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
@staticmethod
def delete_topic(topic):
"""
Deletes a topic. All subscriptions to the topic are also deleted.
"""
try:
topic.delete()
logger.info("Deleted topic %s.", topic.arn)
except ClientError:
logger.exception("Couldn't delete topic %s.", topic.arn)
raise
```
```
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 delete_topic(self, topic_arn: str) -> bool:
"""
Delete an SNS topic.
:param topic_arn: The ARN of the topic to delete.
:return: True if successful.
:raises ClientError: If the topic deletion fails.
"""
try:
self.sns_client.delete_topic(TopicArn=topic_arn)
logger.info(f"Deleted topic: {topic_arn}")
return True
except ClientError as e:
error_code = e.response.get('Error', {}).get('Code', 'Unknown')
if error_code == 'NotFound':
logger.warning(f"Topic not found: {topic_arn}")
return True # Already deleted
else:
logger.error(f"Error deleting topic: {error_code} - {e}")
raise
```
+ Pour plus de détails sur l'API, consultez [DeleteTopic](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/DeleteTopic)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/sns#code-examples).
```
TRY.
lo_sns->deletetopic( iv_topicarn = iv_topic_arn ).
MESSAGE 'SNS topic deleted.' TYPE 'I'.
CATCH /aws1/cx_snsnotfoundexception.
MESSAGE 'Topic does not exist.' TYPE 'E'.
ENDTRY.
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTopic](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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)
_ = try await snsClient.deleteTopic(
input: DeleteTopicInput(topicArn: arn)
)
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteTopic](https://sdk.amazonaws.com/swift/api/awssns/latest/documentation/awssns/snsclient/deletetopic(input:))à la section *AWS SDK pour la référence de l'API Swift*.
------
# Étapes suivantes
Maintenant que vous avez créé une rubrique avec un abonnement et envoyé des messages à la rubrique, testez ce qui suit :
+ Explorez le [Centre pour développeurs AWS](https://aws.amazon.com/developer/).
+ Découvrez comment protéger vos données dans la section [Sécurité](security.md).
+ Activez le [chiffrement côté serveur](sns-enable-encryption-for-topic.md) pour une rubrique.
+ Activez le chiffrement côté serveur pour une rubrique avec une [file d'attente Amazon Simple Queue Service (Amazon SQS) chiffrée](sns-enable-encryption-for-topic-sqs-queue-subscriptions.md) abonnée.
+ Abonnez [AWS Event Fork Pipelines](sns-subscribe-event-fork-pipelines.md) à une rubrique.