Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Creación de un tema de Amazon SNS y publicación de mensajes
<a name="sns-getting-started"></a>

En este tema se describen los pasos básicos para administrar los recursos de Amazon SNS, con especial hincapié en los temas, las suscripciones y la publicación de mensajes. En primer lugar, configurará los permisos de acceso necesarios para Amazon SNS, asegurándose de que dispone de los permisos correctos para crear y administrar recursos de Amazon SNS. A continuación, creará un nuevo tema de Amazon SNS, que servirá como centro neurálgico para administrar y entregar los mensajes a los suscriptores. Tras crear el tema, procederá a crear una suscripción a este tema, lo que permitirá que puntos de conexión específicos reciban los mensajes publicados en él.

Una vez que el tema y la suscripción estén listos, publicará un mensaje en el tema y observará cómo Amazon SNS entrega el mensaje de manera eficaz a todos los puntos de conexión suscritos. Por último, aprenderá a eliminar tanto la suscripción como el tema, completando así el ciclo de vida de los recursos de Amazon SNS que ha administrado. Este enfoque le proporciona una comprensión clara de las operaciones básicas de Amazon SNS, así como las habilidades prácticas necesarias para administrar los flujos de trabajo de mensajería mediante la consola de Amazon SNS.

# Configuración del acceso para Amazon SNS
<a name="sns-setting-up"></a>

Para poder usar Amazon SNS por primera vez, debe completar los pasos siguientes.

## Cree un Cuenta de AWS usuario de IAM
<a name="create-aws-account"></a>

Para acceder a cualquier AWS servicio, primero debe crear un [Cuenta de AWS](https://aws.amazon.com/). Puede usarlo Cuenta de AWS para ver sus informes de actividad y uso y para administrar la autenticación y el acceso.

### Inscríbase en una Cuenta de AWS
<a name="sign-up-for-aws"></a>

Si no tiene uno Cuenta de AWS, complete los siguientes pasos para crearlo.

**Para suscribirse a una Cuenta de AWS**

1. Abrir [https://portal.aws.amazon.com/billing/registro](https://portal.aws.amazon.com/billing/signup).

1. Siga las instrucciones que se le indiquen.

   Parte del procedimiento de registro consiste en recibir una llamada telefónica o mensaje de texto e indicar un código de verificación en el teclado del teléfono.

   Cuando te registras en un Cuenta de AWS, se crea un *usuario Cuenta de AWS root*. El usuario raíz tendrá acceso a todos los Servicios de AWS y recursos de esa cuenta. Como práctica recomendada de seguridad, asigne acceso administrativo a un usuario y utilice únicamente el usuario raíz para realizar [tareas que requieren acceso de usuario raíz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS te envía un correo electrónico de confirmación una vez finalizado el proceso de registro. En cualquier momento, puede ver la actividad de su cuenta actual y administrarla accediendo a [https://aws.amazon.com/](https://aws.amazon.com/)y seleccionando **Mi cuenta**.

### Creación de un usuario con acceso administrativo
<a name="create-an-admin"></a>

Después de registrarte en un usuario Cuenta de AWS raíz Cuenta de AWS, protege tu usuario raíz AWS IAM Identity Center, habilita y crea un usuario administrativo para que no lo utilices en las tareas diarias.

**Proteja a su usuario Cuenta de AWS root**

1.  Inicia sesión [Consola de administración de AWS](https://console.aws.amazon.com/)como propietario de la cuenta; para ello, selecciona el **usuario root** e introduce tu dirección de Cuenta de AWS correo electrónico. En la siguiente página, escriba su contraseña.

   Para obtener ayuda para iniciar sesión con el usuario raíz, consulte [Iniciar sesión como usuario raíz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) en la *Guía del usuario de AWS Sign-In *.

1. Active la autenticación multifactor (MFA) para el usuario raíz.

   Para obtener instrucciones, consulte [Habilitar un dispositivo MFA virtual para el usuario Cuenta de AWS raíz (consola)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) en la Guía del usuario de *IAM*.

**Creación de un usuario con acceso administrativo**

1. Activar IAM Identity Center.

   Consulte las instrucciones en [Activar AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) en la *Guía del usuario de AWS IAM Identity Center *.

1. En IAM Identity Center, conceda acceso administrativo a un usuario.

   Para ver un tutorial sobre su uso Directorio de IAM Identity Center como fuente de identidad, consulte [Configurar el acceso de los usuarios con la configuración predeterminada Directorio de IAM Identity Center en la](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) Guía del *AWS IAM Identity Center usuario*.

**Inicio de sesión como usuario con acceso de administrador**
+ Para iniciar sesión con el usuario de IAM Identity Center, use la URL de inicio de sesión que se envió a la dirección de correo electrónico cuando creó el usuario de IAM Identity Center.

  Para obtener ayuda para iniciar sesión con un usuario del Centro de identidades de IAM, consulte [Iniciar sesión en el portal de AWS acceso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) en la *Guía del AWS Sign-In usuario*.

**Concesión de acceso a usuarios adicionales**

1. En IAM Identity Center, cree un conjunto de permisos que siga la práctica recomendada de aplicar permisos de privilegios mínimos.

   Para conocer las instrucciones, consulte [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) en la *Guía del usuario de AWS IAM Identity Center *.

1. Asigne usuarios a un grupo y, a continuación, asigne el acceso de inicio de sesión único al grupo.

   Para conocer las instrucciones, consulte [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) en la *Guía del usuario de AWS IAM Identity Center *.

## Siguientes pasos
<a name="next-steps-setting-up"></a>

Ahora que está preparado para trabajar con Amazon SNS, empiece realizando las siguientes tareas:

1. [Creación de un tema de Amazon SNS](sns-create-topic.md)

1. [Creación de una suscripción a un tema de Amazon SNS](sns-create-subscribe-endpoint-to-topic.md) 

1. [Publicación de un mensaje de Amazon SNS](sns-publishing.md)

1. [Eliminación de un tema y una suscripción de Amazon SNS](sns-delete-subscription-topic.md)

# Creación de un tema de Amazon SNS
<a name="sns-create-topic"></a>

Un tema de Amazon SNS es un punto de acceso lógico que actúa como un *canal de comunicación*. Un tema le permite agrupar varios *puntos de enlace* (como Amazon SQS AWS Lambda, HTTP/S o una dirección de correo electrónico).

Para difundir los mensajes de un sistema productor de mensajes (por ejemplo, un sitio web de comercio electrónico) que trabaja con otros servicios que requieren sus mensajes (por ejemplo, sistemas de pago y tramitación), puede crear un tema para su sistema productor.

La primera tarea, y la más habitual, en Amazon SNS es la creación de un tema. En esta página se muestra cómo puede utilizar los Consola de administración de AWS AWS SDK para Java, los y los AWS SDK para .NET para crear un tema.

Durante la creación, elige un tipo de tema (estándar o FIFO) y asigna un nombre al tema. Después de un tema, no podrá modificar el tipo o el nombre del tema. Todas las demás opciones de configuración son opcionales durante la creación del tema y puede editarlas más adelante.

**importante**  
No agregue información de identificación personal (PII) ni ninguna otra información confidencial o sensible en los nombres de los temas. Otros Amazon Web Services, incluidos los CloudWatch registros, pueden acceder a los nombres de los temas. Los nombres de los temas no están diseñados para contener información privada o confidencial.

## Para crear un tema mediante el Consola de administración de AWS
<a name="create-topic-aws-console"></a>

La creación de un tema en Amazon SNS sienta las bases para la distribución de mensajes, ya que le permite publicar mensajes que se pueden distribuir de forma ramificada entre varios suscriptores. Este paso es esencial para configurar el tipo de tema, las opciones de cifrado y las políticas de acceso, a fin de garantizar que el tema cumpla los requisitos operativos, de conformidad y de seguridad de la organización.

1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).

1. Realice una de las siguientes acciones:
   + Si nunca se ha creado ningún tema bajo tu Cuenta de AWS dirección, lee la descripción de Amazon SNS en la página de inicio.
   + Si los temas se han creado Cuenta de AWS anteriormente bajo su dirección, en el panel de navegación, elija **Temas**.

1. En la página **Temas**, elija **Crear tema**.

1. En la página **Crear tema**, en la sección **Detalles**, haga lo siguiente:

   1. Para **Tipo**, elija un tipo de tema (**estándar** o **FIFO**).

   1. Ingrese un **nombre** para el nuevo tema. En el caso de un [tema FIFO](sns-fifo-topics.md), agregue **.fifo** al final del nombre.

   1. (Opcional) Ingrese un **nombre para mostrar** para el tema.
**importante**  
Cuando se suscriba a un punto de conexión de correo electrónico, el recuento combinado de caracteres del nombre mostrado del tema de Amazon SNS y de la dirección de correo electrónico de envío (por ejemplo, no-reply@sns.amazonaws.com) no debe superar los 320 caracteres UTF-8. Puede utilizar una herramienta de codificación de terceros para verificar la longitud de la dirección de envío antes de configurar un nombre para mostrar para su tema de Amazon SNS.

   1. (Opcional) En el caso de un tema FIFO, puede elegir **Desduplicación de mensajes basada en el contenido** para habilitar la desduplicación de mensajes predeterminada. Para obtener más información, consulte [Desduplicación de mensajes de Amazon SNS para temas FIFO](fifo-message-dedup.md).

1. (Opcional) Expanda la sección **Encryption (Cifrado)** y haga lo siguiente. Para obtener más información, consulte [Protección de los datos de Amazon SNS con cifrado del servidor](sns-server-side-encryption.md).

   1. Elija **Habilitar el cifrado**.

   1. Especifique la AWS KMS clave. Para obtener más información, consulte [Términos clave](sns-server-side-encryption.md#sse-key-terms).

      Se muestran los valores de **Description (Descripción)**, **Account (Cuenta)** y **KMS ARN (ARN de KMS)** de cada tipo de KMS.
**importante**  
Si no es el propietario de la KMS o si ha iniciado sesión con una cuenta que no tiene los permisos `kms:ListAliases` y `kms:DescribeKey`, no podrá ver la información sobre la KMS en la consola de Amazon SNS.  
Pida al propietario de la KMS que le conceda estos permisos. Para obtener más información, consulte [Permisos API de AWS KMS : referencia de recursos y acciones](https://docs.aws.amazon.com/kms/latest/developerguide/kms-api-permissions-reference.html) en la *Guía para desarrolladores de AWS Key Management Service *.
      + El KMS AWS gestionado para Amazon SNS **(predeterminado) alias/aws/sns** está seleccionado de forma predeterminada.
**nota**  
Tenga en cuenta lo siguiente:  
La primera vez que utilice Consola de administración de AWS para especificar el KMS AWS administrado para Amazon SNS para un tema, AWS KMS crea el KMS AWS administrado para Amazon SNS.
Como alternativa, la primera vez que utilice la `Publish` acción en un tema con SSE habilitado, AWS KMS creará el KMS AWS administrado para Amazon SNS.
      + Para usar un KMS personalizado de su AWS cuenta, elija el campo **clave de KMS** y, a continuación, elija el KMS personalizado de la lista.
**nota**  
Para obtener instrucciones sobre cómo crear claves personalizadas KMSs, consulte [Creación de claves](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) en la *Guía para AWS Key Management Service desarrolladores*
      + Para usar un ARN de KMS personalizado de su AWS cuenta o de otra AWS cuenta, introdúzcalo en el campo de **clave de KMS**.

1. (Opcional) De forma predeterminada, solo el propietario del tema puede publicar en el tema o suscribirse a este. Para configurar permisos de acceso adicionales, expanda la sección **Access policy (Política de acceso)**. Para obtener más información, consulte [Identity and Access Management en Amazon SNS](security-iam.md) y [Ejemplos de casos de control de acceso con Amazon SNS](sns-access-policy-use-cases.md). 
**nota**  
Cuando se crea un tema a través de la consola, la política predeterminada utiliza la clave de condición `aws:SourceOwner`. Esta clave es similar a `aws:SourceAccount`. 

1. (Opcional) Para configurar la forma en que Amazon SNS reintenta los intentos de entrega de mensajes con error, expanda la sección **Política de reintentos de entrega (HTTP/S)**. Para obtener más información, consulte [Reintento de entrega de mensajes de Amazon SNS](sns-message-delivery-retries.md).

1. (Opcional) Para configurar la forma en que Amazon SNS registra la entrega de mensajes CloudWatch, amplíe la sección **Registro del estado de entrega**. Para obtener más información, consulte [Estado de entrega de mensajes de Amazon SNS](sns-topic-attributes.md).

1. (Opcional) Para añadir etiquetas de metadatos al tema, expanda la sección **Tags (Etiquetas)**, escriba un valor en **Key (Clave)** y en **Value (Valor)** (opcional) y elija **Add tag (Añadir etiqueta)**. Para obtener más información, consulte [Etiquetado de temas de Amazon SNS](sns-tags.md).

1. Seleccione **Crear tema**.

   Se crea el tema y se muestra la ***MyTopic***página.

   El **nombre** del tema, el **ARN**, el **nombre para mostrar** (opcional) y el ID de AWS cuenta del **propietario del tema** se muestran en la sección **Detalles**.

1. Copie el ARN del tema en el portapapeles, por ejemplo:

   ```
   arn:aws:sns:us-east-2:123456789012:MyTopic
   ```

## Para crear un tema mediante un SDK AWS
<a name="create-topic-aws-sdks"></a>

Para usar un AWS SDK, debe configurarlo con sus credenciales. Para obtener más información, consulte [Los archivos de configuración y credenciales compartidos](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) en la *Guía de referencia de herramientas AWS SDKs y herramientas*.

Los siguientes ejemplos de código muestran cómo utilizar `CreateTopic`.

------
#### [ .NET ]

**SDK para .NET**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SNS#code-examples). 
Cree un tema con un nombre específico.  

```
    using System;
    using System.Threading.Tasks;
    using Amazon.SimpleNotificationService;
    using Amazon.SimpleNotificationService.Model;

    /// <summary>
    /// This example shows how to use Amazon Simple Notification Service
    /// (Amazon SNS) to add a new Amazon SNS topic.
    /// </summary>
    public class CreateSNSTopic
    {
        public static async Task Main()
        {
            string topicName = "ExampleSNSTopic";

            IAmazonSimpleNotificationService client = new AmazonSimpleNotificationServiceClient();

            var topicArn = await CreateSNSTopicAsync(client, topicName);
            Console.WriteLine($"New topic ARN: {topicArn}");
        }

        /// <summary>
        /// Creates a new SNS topic using the supplied topic name.
        /// </summary>
        /// <param name="client">The initialized SNS client object used to
        /// create the new topic.</param>
        /// <param name="topicName">A string representing the topic name.</param>
        /// <returns>The Amazon Resource Name (ARN) of the created topic.</returns>
        public static async Task<string> CreateSNSTopicAsync(IAmazonSimpleNotificationService client, string topicName)
        {
            var request = new CreateTopicRequest
            {
                Name = topicName,
            };

            var response = await client.CreateTopicAsync(request);

            return response.TopicArn;
        }
    }
```
Cree un tema nuevo con un nombre y atributos específicos de FIFO y desduplicación.  

```
    /// <summary>
    /// Create a new topic with a name and specific FIFO and de-duplication attributes.
    /// </summary>
    /// <param name="topicName">The name for the topic.</param>
    /// <param name="useFifoTopic">True to use a FIFO topic.</param>
    /// <param name="useContentBasedDeduplication">True to use content-based de-duplication.</param>
    /// <returns>The ARN of the new topic.</returns>
    public async Task<string> CreateTopicWithName(string topicName, bool useFifoTopic, bool useContentBasedDeduplication)
    {
        var createTopicRequest = new CreateTopicRequest()
        {
            Name = topicName,
        };

        if (useFifoTopic)
        {
            // Update the name if it is not correct for a FIFO topic.
            if (!topicName.EndsWith(".fifo"))
            {
                createTopicRequest.Name = topicName + ".fifo";
            }

            // Add the attributes from the method parameters.
            createTopicRequest.Attributes = new Dictionary<string, string>
            {
                { "FifoTopic", "true" }
            };
            if (useContentBasedDeduplication)
            {
                createTopicRequest.Attributes.Add("ContentBasedDeduplication", "true");
            }
        }

        var createResponse = await _amazonSNSClient.CreateTopicAsync(createTopicRequest);
        return createResponse.TopicArn;
    }
```
+  Para obtener más información sobre la API, consulta [CreateTopic](https://docs.aws.amazon.com/goto/DotNetSDKV3/sns-2010-03-31/CreateTopic)la *Referencia AWS SDK para .NET de la API*. 

------
#### [ C\$1\$1 ]

**SDK para C\$1\$1**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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();
}
```
+  Para obtener más información sobre la API, consulta [CreateTopic](https://docs.aws.amazon.com/goto/SdkForCpp/sns-2010-03-31/CreateTopic)la *Referencia AWS SDK para C\$1\$1 de la API*. 

------
#### [ CLI ]

**AWS CLI**  
**Creación de un tema de SNS**  
En el siguiente ejemplo de `create-topic` se crea un tema de SNS denominado `my-topic`.  

```
aws sns create-topic \
    --name my-topic
```
Salida:  

```
{
    "ResponseMetadata": {
        "RequestId": "1469e8d7-1642-564e-b85d-a19b4b341f83"
    },
    "TopicArn": "arn:aws:sns:us-west-2:123456789012:my-topic"
}
```
Para obtener más información, consulte [Uso de la interfaz de línea de AWS comandos con Amazon SQS y Amazon SNS](https://docs.aws.amazon.com/cli/latest/userguide/cli-sqs-queue-sns-topic.html) en la Guía del usuario de *AWS la interfaz de línea de comandos*.  
+  Para obtener más información sobre la API, consulte la Referencia [CreateTopic](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/create-topic.html)de *AWS CLI comandos*. 

------
#### [ Go ]

**SDK para Go V2**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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
}
```
+  Para obtener más información sobre la API, consulta [CreateTopic](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sns#Client.CreateTopic)la *Referencia AWS SDK para Go de la API*. 

------
#### [ Java ]

**SDK para Java 2.x**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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:    <topicName>

                Where:
                   topicName - The name of the topic to create (for example, mytopic).

                """;

        if (args.length != 1) {
            System.out.println(usage);
            System.exit(1);
        }

        String topicName = args[0];
        System.out.println("Creating a topic with name: " + topicName);
        SnsClient snsClient = SnsClient.builder()
                .region(Region.US_EAST_1)
                .build();

        String arnVal = createSNSTopic(snsClient, topicName);
        System.out.println("The topic ARN is" + arnVal);
        snsClient.close();
    }

    public static String createSNSTopic(SnsClient snsClient, String topicName) {
        CreateTopicResponse result;
        try {
            CreateTopicRequest request = CreateTopicRequest.builder()
                    .name(topicName)
                    .build();

            result = snsClient.createTopic(request);
            return result.topicArn();

        } catch (SnsException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return "";
    }
}
```
+  Para obtener más información sobre la API, consulta [CreateTopic](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/CreateTopic)la *Referencia AWS SDK for Java 2.x de la API*. 

------
#### [ JavaScript ]

**SDK para JavaScript (v3)**  
 Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples). 
Cree el cliente en un módulo separado y expórtelo.  

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```
Importe el SDK y los módulos cliente, y llame a la 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;
};
```
+  Para obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topics-createtopic). 
+  Para obtener más información sobre la API, consulta [CreateTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/CreateTopicCommand)la *Referencia AWS SDK para JavaScript de la API*. 

------
#### [ Kotlin ]

**SDK para Kotlin**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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()
    }
}
```
+  Para obtener más información sobre la API, consulta [CreateTopic](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la *referencia sobre el AWS SDK para la API de Kotlin*. 

------
#### [ PHP ]

**SDK para PHP**  
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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());
}
```
+  Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-managing-topics.html#create-a-topic). 
+  Para obtener más información sobre la API, consulta [CreateTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/CreateTopic)la *Referencia AWS SDK para PHP de la API*. 

------
#### [ Python ]

**SDK para Python (Boto3)**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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
```
+  Para obtener más información sobre la API, consulta [CreateTopic](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/CreateTopic)la *AWS Referencia de API de SDK for Python (Boto3*). 

------
#### [ Ruby ]

**SDK para Ruby**  
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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
```
+  Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/sns-example-create-topic.html). 
+  Para obtener más información sobre la API, consulta [CreateTopic](https://docs.aws.amazon.com/goto/SdkForRubyV3/sns-2010-03-31/CreateTopic)la *Referencia AWS SDK para Ruby de la API*. 

------
#### [ Rust ]

**SDK para Rust**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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(())
}
```
+  Para obtener más información sobre la API, consulta [CreateTopic](https://docs.rs/aws-sdk-sns/latest/aws_sdk_sns/client/struct.Client.html#method.create_topic)la *referencia sobre la API de AWS SDK para Rust*. 

------
#### [ SAP ABAP ]

**SDK para SAP ABAP**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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.
```
+  Para obtener más información sobre la API, consulte [CreateTopic](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la *referencia sobre la API ABAP del AWS SDK para SAP*. 

------
#### [ Swift ]

**SDK para Swift**  
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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
        }
```
+  Para obtener más información sobre la API, consulta [CreateTopic](https://sdk.amazonaws.com/swift/api/awssns/latest/documentation/awssns/snsclient/createtopic(input:))la *referencia sobre la API de AWS SDK for Swift*. 

------

# Creación de una suscripción a un tema de Amazon SNS
<a name="sns-create-subscribe-endpoint-to-topic"></a>

Para recibir los mensajes publicados en un [tema](sns-create-topic.md), tiene que *suscribirse* a un [punto de enlace](#sns-endpoints) en el tema. Cuando suscriba un punto de enlace a un tema, el punto de enlace comenzará a recibir todos los mensajes publicados en el tema asociado.

**nota**  
Los puntos de enlace HTTP (S), las direcciones de correo electrónico y los AWS recursos, entre otros, Cuentas de AWS requieren la confirmación de la suscripción antes de poder recibir mensajes.

## Para suscribir un punto de enlace a un tema de Amazon SNS, siga estos pasos:
<a name="subscribe-topic-aws-console"></a>

La suscripción de un punto de conexión a un tema de Amazon SNS permite la entrega de mensajes al punto de conexión especificado, lo que garantiza que los sistemas o usuarios correctos reciban notificaciones cuando se publique un mensaje en el tema. Este paso es esencial para vincular el tema con los consumidores, ya sean aplicaciones, destinatarios de correo electrónico u otros servicios, lo que permite una comunicación fluida entre los sistemas.

1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).

1. En el panel de navegación izquierdo, elija **Suscripciones**.

1. En la página **Subscriptions (Suscripciones)**, elija **Create subscription (Crear suscripción)**.

1. En la página **Crear suscripción**, en la sección **Detalles**, haga lo siguiente:

   1. En **ARN de tema**, elija el nombre de recurso de Amazon (ARN) de un tema. Este valor es el AWS ARN que se generó al crear el tema Amazon SNS, por ejemplo. `arn:aws:sns:us-east-2:123456789012:your_topic`

   1. En **Protocolo**, elija un tipo de punto de enlace.  Los tipos de puntos de enlace disponibles son:
      + [**HTTP/HTTPS**](sns-http-https-endpoint-as-subscriber.md)
      + [**Correo electrónico/Correo electrónico JSON**](sns-email-notifications.md)
      + [****](sns-firehose-as-subscriber.md)
      + [**Amazon SQS**](sns-sqs-as-subscriber.md)
**nota**  
Para suscribirse a un [tema de SNS FIFO](sns-fifo-topics.md), elija esta opción.
      + [**AWS Lambda**](sns-lambda-as-subscriber.md)
      + [**Punto de conexión de aplicación de plataforma**](sns-mobile-application-as-subscriber.md)
      + [**SMS**](sns-mobile-phone-number-as-subscriber.md) 

   1. En **Punto de enlace**, ingrese el valor del punto de enlace, como una dirección de correo electrónico o el ARN de una cola de Amazon SQS.

   1. Solo para los puntos de conexión de Firehose: en **ARN del rol de suscripción**, especifique el ARN del rol de IAM que creó para escribir en flujos de entrega de Firehose. Para obtener más información, consulte [Requisitos previos para suscribir flujos de entrega de Firehose a temas de Amazon SNS](prereqs-kinesis-data-firehose.md).

   1. (Opcional) Para Firehose, Amazon SQS y puntos de conexión HTTP/S , también puede habilitar la entrega de mensajes sin procesar. Para obtener más información, consulte [Entrega de mensajes sin procesar de Amazon SNS](sns-large-payload-raw-message-delivery.md).

   1. (Opcional) Para configurar una política de filtro, expanda la sección **Política de filtro de suscripción**. Para obtener más información, consulte [Políticas de filtro de suscripciones de Amazon SNS](sns-subscription-filter-policies.md).

   1. (Opcional) Para habilitar el filtrado basado en cargas, configure `Filter Policy Scope` en `MessageBody`. Para obtener más información, consulte [Alcance de políticas de filtrado de suscripciones de Amazon SNS](sns-message-filtering-scope.md).

   1. (Opcional) Para configurar una cola de mensajes fallidos en la suscripción, expanda la sección **Política de reconducción (cola de mensajes fallidos)**. Para obtener más información, consulte [Colas de mensajes fallidos de Amazon SNS](sns-dead-letter-queues.md).

   1. Seleccione **Crear subscripción**.

      En la consola se crea la suscripción y se abre la página **Detalles** de la suscripción.

# Publicación de un mensaje de Amazon SNS
<a name="sns-publishing"></a>

Después de [crear un tema de Amazon SNS](sns-create-topic.md) y suscribir un [punto de enlace](sns-create-subscribe-endpoint-to-topic.md) a él, puede *publicar* mensajes en un tema. Cuando se publica un mensaje, Amazon SNS intenta entregar el mensaje al [punto de enlace](sns-create-subscribe-endpoint-to-topic.md#sns-endpoints) suscrito. 

## Para publicar mensajes en los temas de Amazon SNS mediante Consola de administración de AWS
<a name="sns-publishing-messages"></a>

1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).

1. En el panel de navegación izquierdo, elija **Topics (Temas)**.

1. En la página **Temas**, seleccione un tema y, a continuación, elija **Publicar en tema**.

   En la consola, se abre la página **Publicar mensaje en un tema**.

1. En la sección **Detalles básicos**, haga lo siguiente:

   1. (Opcional) Ingrese un **asunto** para el mensaje.

   1. En el caso de un [tema FIFO](sns-fifo-topics.md), ingrese un **ID de grupo de mensajes**. Se requiere un **ID de grupo de mensajes** para los temas FIFO. Los mensajes del mismo grupo de mensajes se entregan en el orden en que se publican.

   1. (Opcional) Para un tema estándar, introduzca un **ID de grupo de mensajes**. Este ID se reenvía a todas las suscripciones estándar de Amazon SQS y no se utiliza ni se envía a ningún otro tipo de punto de conexión. 

   1. En el caso de un tema FIFO, escriba un **ID de desduplicación de mensajes**. Este ID es opcional si ha habilitado la configuración **Desduplicación de mensajes en función del contenido** para el tema.

   1. (Opcional) En el caso de las [notificaciones push en móviles](sns-ttl.md), ingrese un valor de **período de vida (TTL)** en segundos. Esta es la cantidad de tiempo que un servicio de notificaciones push, como Apple Push Notification Service (APNs) o Firebase Cloud Messaging (FCM), tiene para entregar el mensaje al punto final.

1. En la sección **Message body (Cuerpo del mensaje)**, realice alguna de las siguientes acciones:

   1. Elija **Carga idéntica para todos los protocolos de entrega** y, a continuación, ingrese el mensaje.

   1. Elija **Carga personalizada para cada protocolo de entrega** y, a continuación, ingrese un objeto JSON para definir el mensaje que se envía a cada protocolo.

      Para obtener más información, consulte [Publicación de notificaciones de Amazon SNS con cargas útiles específicas de la plataforma](sns-send-custom-platform-specific-payloads-mobile-devices.md).

1. En la sección **Atributos del mensaje**, agregue cualquier atributo que quiera que Amazon SNS haga coincidir con el atributo `FilterPolicy` de la suscripción y, de esta manera, poder decidir si el punto de enlace suscrito tiene interés en el mensaje publicado.

   1. En **Tipo**, elija un tipo de atributo, como **Matriz.Cadena**.
**nota**  
Para el tipo de atributo **Matriz.Cadena**, incluya la matriz entre corchetes (`[]`). Dentro de la matriz, delimite los valores de cadena con comillas dobles. No es necesario usar comillas con los números ni con las palabras clave `true`, `false` y `null`.

   1. Ingrese un **nombre** para el atributo, como, por ejemplo, `customer_interests`.

   1. Ingrese un **valor** para el atributo, como, por ejemplo, `["soccer", "rugby", "hockey"]`.

   Si el tipo de atributo es **String** (Cadena), **String.Array** (Matriz.Cadena) o **Number** (Número), Amazon SNS evalúa el atributo del mensaje con la [filter policy](sns-message-filtering.md) (política de filtrado) de una suscripción (si existe), antes de enviar el mensaje a la suscripción cuyo ámbito de políticas de filtrado proporcionado no esté establecido explícitamente en `MessageBody`.

   Para obtener más información, consulte [Atributos de mensajes de Amazon SNS](sns-message-attributes.md).

1. Elija **Publish message (Publicar mensaje)**.

   El mensaje se publica en el tema. Además, en la consola, se abre la página **Detalles**.

## Para publicar un mensaje en un tema mediante un SDK AWS
<a name="publish-to-topic-aws-sdks"></a>

Para usar un AWS SDK, debe configurarlo con sus credenciales. Para obtener más información, consulte [Los archivos de configuración y credenciales compartidos](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) en la *Guía de referencia de herramientas AWS SDKs y herramientas*.

Los siguientes ejemplos de código muestran cómo utilizar `Publish`.

------
#### [ .NET ]

**SDK para .NET**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/SNS#code-examples). 
Publique un mensaje en un tema  

```
    using System;
    using System.Threading.Tasks;
    using Amazon.SimpleNotificationService;
    using Amazon.SimpleNotificationService.Model;

    /// <summary>
    /// This example publishes a message to an Amazon Simple Notification
    /// Service (Amazon SNS) topic.
    /// </summary>
    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);
        }

        /// <summary>
        /// Publishes a message to an Amazon SNS topic.
        /// </summary>
        /// <param name="client">The initialized client object used to publish
        /// to the Amazon SNS topic.</param>
        /// <param name="topicArn">The ARN of the topic.</param>
        /// <param name="messageText">The text of the message.</param>
        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}");
        }
    }
```
Publique un mensaje en un tema con opciones de grupo, duplicación y atributo  

```
    /// <summary>
    /// Publish messages using user settings.
    /// </summary>
    /// <returns>Async task.</returns>
    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);
        }
    }
```
Aplique las selecciones del usuario a la acción de publicación.  

```
    /// <summary>
    /// Publish a message to a topic with an attribute and optional deduplication and group IDs.
    /// </summary>
    /// <param name="topicArn">The ARN of the topic.</param>
    /// <param name="message">The message to publish.</param>
    /// <param name="attributeName">The optional attribute for the message.</param>
    /// <param name="attributeValue">The optional attribute value for the message.</param>
    /// <param name="deduplicationId">The optional deduplication ID for the message.</param>
    /// <param name="groupId">The optional group ID for the message.</param>
    /// <returns>The ID of the message published.</returns>
    public async Task<string> 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<string, MessageAttributeValue>
                {
                    { attributeName!, new MessageAttributeValue() { StringValue = attributeValue, DataType = "String"} }
                };
        }

        var publishResponse = await _amazonSNSClient.PublishAsync(publishRequest);
        return publishResponse.MessageId;
    }
```
+  Para obtener detalles sobre la API, consulte [Publish](https://docs.aws.amazon.com/goto/DotNetSDKV3/sns-2010-03-31/Publish) en la *Referencia de la API de AWS SDK para .NET *. 

------
#### [ C\$1\$1 ]

**SDK para C\$1\$1**  
 Hay más información GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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();
}
```
Publique un mensaje con un atributo.  

```
        static const Aws::String TONE_ATTRIBUTE("tone");
        static const Aws::Vector<Aws::String> 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<int>(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;
        }
```
+  Para obtener detalles sobre la API, consulte [Publish](https://docs.aws.amazon.com/goto/SdkForCpp/sns-2010-03-31/Publish) en la *Referencia de la API de AWS SDK para C\$1\$1 *. 

------
#### [ CLI ]

**AWS CLI**  
**Ejemplo 1: Publicar un mensaje en un tema**  
En el siguiente ejemplo de `publish` se publica el mensaje especificado en el tema de SNS especificado. El mensaje proviene de un archivo de texto que le permite incluir saltos de línea.  

```
aws sns publish \
    --topic-arn "arn:aws:sns:us-west-2:123456789012:my-topic" \
    --message file://message.txt
```
Contenido de `message.txt`:  

```
Hello World
Second Line
```
Salida:  

```
{
    "MessageId": "123a45b6-7890-12c3-45d6-111122223333"
}
```
**Ejemplo 2: publicar un mensaje SMS en un número de teléfono**  
En el siguiente ejemplo de `publish`, se publica el mensaje `Hello world!` en el número de teléfono `+1-555-555-0100`.  

```
aws sns publish \
    --message "Hello world!" \
    --phone-number +1-555-555-0100
```
Salida:  

```
{
    "MessageId": "123a45b6-7890-12c3-45d6-333322221111"
}
```
+  Para obtener detalles sobre la API, consulte [Publish](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/publish.html) en la *Referencia del comando de la AWS CLI *. 

------
#### [ Go ]

**SDK para Go V2**  
 Hay más información GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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
}
```
+  Para obtener detalles sobre la API, consulte [Publish](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sns#Client.Publish) en la *Referencia de la API de AWS SDK para Go *. 

------
#### [ Java ]

**SDK para Java 2.x**  
 Hay más información GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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:    <message> <topicArn>

                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);
        }
    }
}
```
+  Para obtener detalles sobre la API, consulte [Publish](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/Publish) en la *Referencia de la API de AWS SDK for Java 2.x *. 

------
#### [ JavaScript ]

**SDK para JavaScript (v3)**  
 Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples). 
Cree el cliente en un módulo separado y expórtelo.  

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```
Importe el SDK y los módulos cliente, y llame a la API.  

```
import { PublishCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string | Record<string, any>} 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;
};
```
Publique un mensaje en un tema con opciones de grupo, duplicación y atributo.  

```
  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();
    }
  }
```
+  Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-publishing-messages.html). 
+  Para obtener detalles sobre la API, consulte [Publish](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/PublishCommand) en la *Referencia de la API de AWS SDK para JavaScript *. 

------
#### [ Kotlin ]

**SDK para Kotlin**  
 Hay más información GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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.")
    }
}
```
+  Para obtener detalles sobre la API, consulte [Publish](https://sdk.amazonaws.com/kotlin/api/latest/index.html) en la *Referencia de la API de AWS SDK para Kotlin*. 

------
#### [ PHP ]

**SDK para PHP**  
 Hay más información GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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());
}
```
+  Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para 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). 
+  Para obtener detalles sobre la API, consulte [Publish](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Publish) en la *Referencia de la API de AWS SDK para PHP *. 

------
#### [ PowerShell ]

**Herramientas para la PowerShell V4**  
**Ejemplo 1: En este ejemplo se muestra la publicación de un mensaje con una sola línea MessageAttribute declarada.**  

```
Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute @{'City'=[Amazon.SimpleNotificationService.Model.MessageAttributeValue]@{DataType='String'; StringValue ='AnyCity'}}
```
**Ejemplo 2: En este ejemplo se muestra la publicación de un mensaje con varios MessageAttributes declarados de antemano.**  

```
$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
```
+  Para obtener información sobre la API, consulte [Publish](https://docs.aws.amazon.com/powershell/v4/reference) en la *Referencia de cmdlets de Herramientas de AWS para PowerShell (V4)*. 

**Herramientas para la PowerShell versión 5**  
**Ejemplo 1: En este ejemplo se muestra la publicación de un mensaje con una sola MessageAttribute línea declarada.**  

```
Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute @{'City'=[Amazon.SimpleNotificationService.Model.MessageAttributeValue]@{DataType='String'; StringValue ='AnyCity'}}
```
**Ejemplo 2: En este ejemplo se muestra la publicación de un mensaje con varios MessageAttributes declarados de antemano.**  

```
$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
```
+  Para obtener información sobre la API, consulte [Publish](https://docs.aws.amazon.com/powershell/v5/reference) en la *Referencia de cmdlets de Herramientas de AWS para PowerShell (V5)*. 

------
#### [ Python ]

**SDK para Python (Boto3)**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/sns#code-examples). 
Publique un mensaje con atributos para que una suscripción pueda filtrar en función de los atributos.  

```
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
```
Publique un mensaje que toma diferentes formas en función del protocolo del suscriptor.  

```
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
```
+  Para obtener detalles sobre la API, consulte [Publish](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/Publish) en la *Referencia de la API de AWS SDK para Python (Boto3)*. 

------
#### [ Ruby ]

**SDK para Ruby**  
 Hay más información GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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
```
+  Para obtener más información, consulte la [Guía para desarrolladores de AWS SDK para Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/sns-example-send-message.html). 
+  Para obtener información sobre la API, consulte [Publicar](https://docs.aws.amazon.com/goto/SdkForRubyV3/sns-2010-03-31/Publish) en la *Referencia de la API de AWS SDK para Ruby *. 

------
#### [ Rust ]

**SDK para Rust**  
 Hay más información GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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(())
}
```
+  Para obtener detalles sobre la API, consulte [Publish](https://docs.rs/aws-sdk-sns/latest/aws_sdk_sns/client/struct.Client.html#method.publish) en la *Referencia de la API de AWS SDK para Rust*. 

------
#### [ SAP ABAP ]

**SDK para SAP ABAP**  
 Hay más información GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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.
```
Publica un mensaje con los atributos de un tema.  

```
    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.
```
Publica un mensaje multiformato en un tema.  

```
    " 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.
```
+  Para obtener detalles sobre la API, consulte [Publish](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) en la *Referencia de la API de AWS SDK para SAP ABAP*. 

------
#### [ Swift ]

**SDK para Swift**  
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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)")
```
+  Para obtener detalles sobre la API, consulte [Publish](https://sdk.amazonaws.com/swift/api/awssns/latest/documentation/awssns/snsclient/publish(input:)) en la *Referencia de la API de AWS SDK para Swift*. 

------

# Publicación de mensajes grandes con Amazon SNS y Amazon S3
<a name="large-message-payloads"></a>

Para publicar mensajes grandes de Amazon SNS, puede utilizar la [biblioteca de clientes ampliada de Amazon SNS para Java](https://github.com/awslabs/amazon-sns-java-extended-client-lib/) o la [biblioteca de clientes ampliada de Amazon SNS para Python](https://github.com/awslabs/amazon-sns-python-extended-client-lib). Estas bibliotecas son útiles para los mensajes que superan el máximo actual de 256 KB, con un máximo de 2 GB. Ambas bibliotecas guardan la carga útil real en un bucket de Amazon S3 y publican la referencia del objeto de Amazon S3 almacenado en el tema de Amazon SNS. Las colas de Amazon SQS suscritas pueden utilizar la [biblioteca de clientes extendidos de Amazon SQS para Java](https://github.com/awslabs/amazon-sqs-java-extended-client-lib) con el fin de eliminar la referencia y recuperar cargas de Amazon S3. Otros puntos de conexión, como Lambda, pueden utilizar la [descarga de carga de la biblioteca común de Java para AWS](https://github.com/awslabs/payload-offloading-java-common-lib-for-aws) con el fin de eliminar la referencia y recuperar la carga.

**nota**  
Las bibliotecas de clientes ampliadas de Amazon SNS son compatibles con temas estándar y FIFO.

# Biblioteca de clientes ampliada de Amazon SNS para Java
<a name="extended-client-library-java"></a>

## Requisitos previos
<a name="prereqs-sns-extended-client-library"></a>

A continuación, se enumeran los requisitos previos para utilizar la [biblioteca de clientes ampliada de Amazon SNS para Java](https://github.com/awslabs/amazon-sns-java-extended-client-lib):
+ Un AWS SDK. El ejemplo de esta página usa el SDK de AWS Java. Para instalar y configurar el SDK, consulte [Configurar el AWS SDK para Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-install.html) en la *Guía para AWS SDK para Java desarrolladores*.
+ Y Cuenta de AWS con las credenciales adecuadas. Para crear una Cuenta de AWS, vaya a la [página de AWS inicio](https://aws.amazon.com/) y, a continuación, seleccione **Crear una AWS cuenta**. Siga las instrucciones.

  Para obtener información sobre las credenciales, consulte [Configurar AWS las credenciales y la región para el desarrollo](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-credentials.html) en la *Guía para AWS SDK para Java desarrolladores*.
+ Java 8 o superior. 
+ La biblioteca de clientes ampliada de Amazon SNS para Java (también disponible en [Maven](https://maven.apache.org/)). 

## Configuración del almacenamiento de mensajes
<a name="large-message-configure-storage"></a>

La biblioteca Amazon SNS Extended Client utiliza la biblioteca común de Java Payload Offloading AWS para almacenar y recuperar mensajes. Puede configurar las siguientes [opciones de almacenamiento de mensajes](https://github.com/awslabs/amazon-sns-java-extended-client-lib/blob/main/src/main/java/software/amazon/sns/SNSExtendedClientConfiguration.java) de Amazon S3:
+ **Umbral de tamaños de mensajes personalizados**: los mensajes con cargas útiles y atributos que superan este tamaño se almacenan de manera automática en Amazon S3.
+ **Indicador de `alwaysThroughS3`**: establezca este valor en `true` para forzar que todas las cargas útiles de mensajes se almacenen en Amazon S3. Por ejemplo:

  ```
  SNSExtendedClientConfiguration snsExtendedClientConfiguration = new
  SNSExtendedClientConfiguration() .withPayloadSupportEnabled(s3Client, BUCKET_NAME).withAlwaysThroughS3(true);
  ```
+ **Clave KMS personalizada**: la clave que se utiliza para el cifrado del servidor en su bucket de Amazon S3.
+ **Nombre del bucket**: el nombre del bucket de Amazon S3 para almacenar cargas útiles de mensajes. 

## Ejemplo: Publicación de mensajes en Amazon SNS con carga almacenada en Amazon S3
<a name="example-s3-large-payloads"></a>

En el siguiente ejemplo de código, se muestra cómo:
+ Crear un tema y una cola de ejemplo.
+ Suscriba la cola para recibir mensajes del tema.
+ Publique un mensaje de prueba.

La carga del mensaje se almacena en Amazon S3 y se publica la referencia a ella. El cliente extendido de Amazon SQS se utiliza para recibir el mensaje.

**SDK para Java 1.x**  
 Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/java/example_code/sns#code-examples). 
Para publicar mensajes grandes, utilice la biblioteca de clientes extendidos de Amazon SNS para Java. El mensaje que envía hace referencia a un objeto de Amazon S3 en el que se incluye el contenido real del mensaje.  

```
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());
        }
}
```

## Otros protocolos de puntos de enlace
<a name="large-payloads-other-protocols"></a>

Tanto las bibliotecas de Amazon SNS como Amazon SQS utilizan la [descarga de carga de la biblioteca común de Java para AWS](https://github.com/awslabs/payload-offloading-java-common-lib-for-aws) con el fin de almacenar y recuperar cargas de mensajes con Amazon S3. Cualquier punto de enlace habilitado para Java (por ejemplo, un punto de enlace HTTPS implementado en Java) puede usar la misma biblioteca para eliminar la referencia al contenido del mensaje.

Los puntos de enlace que no puedan utilizar la biblioteca común de Java para la descarga de cargas útiles AWS pueden seguir publicando mensajes con cargas útiles almacenadas en Amazon S3. A continuación, mostramos un ejemplo de una referencia de Amazon S3 que se publica mediante el ejemplo de código anterior:

```
[
  "software.amazon.payloadoffloading.PayloadS3Pointer",
  {
    "s3BucketName": "extended-client-bucket",
    "s3Key": "xxxx-xxxxx-xxxxx-xxxxxx"
  }
]
```

# Biblioteca de clientes ampliada de Amazon SNS para Python
<a name="extended-client-library-python"></a>

## Requisitos previos
<a name="prereqs-sns-extended-client-library-python"></a>

A continuación, se indican los requisitos previos para utilizar la [biblioteca de clientes ampliada de Amazon SNS para Python](https://github.com/awslabs/amazon-sns-python-extended-client-lib):
+ Un AWS SDK. El ejemplo de esta página usa AWS Python SDK Boto3. Para instalar y configurar el SDK, consulte la documentación del [https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html).
+ Y Cuenta de AWS con las credenciales adecuadas. Para crear una Cuenta de AWS, vaya a la [página de AWS inicio](https://aws.amazon.com/) y, a continuación, seleccione **Crear una AWS cuenta**. Siga las instrucciones.

  Para obtener información sobre las credenciales, consulte [Credenciales](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) en la *Guía para desarrolladores del SDK de AWS para Python*.
+ Python 3.x (o posterior) y pip.
+ La biblioteca de clientes ampliada de Amazon SNS para Python (también disponible en [PyPI](https://pypi.org/project/amazon-sns-extended-client/)). 

## Configuración del almacenamiento de mensajes
<a name="large-message-configure-storage-python"></a>

Los siguientes atributos están disponibles en el cliente[,](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns/topic/index.html) tema [PlatformEndpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns/platformendpoint/index.html)y objetos de Amazon [SNS](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#client) de Boto3 para configurar las opciones de almacenamiento de mensajes de Amazon S3.
+ **`large_payload_support`**: el nombre del bucket de Amazon S3 que almacenará los mensajes de gran tamaño.
+ **`use_legacy_attribute`**: si es `True`, entonces todos los mensajes publicados utilizan el atributo de mensaje reservado heredado (`SQSLargePayloadSize`) en lugar del atributo de mensaje reservado actual (`ExtendedPayloadSize`).
+ **`message_size_threshold`**: el umbral para almacenar el mensaje en el bucket de mensajes de gran tamaño. No puede ser inferior a `0`, ni superior a `262144`. El valor predeterminado es `262144`.
+ **`always_through_s3`**: si `True`, todos los mensajes se almacenan en Amazon S3. El valor predeterminado es `False`.
+ **`s3_client`**: el objeto `client` de Amazon S3 de Boto3 que debe utilizarse para almacenar objetos en Amazon S3. Utilícelo si desea controlar el cliente de Amazon S3 (por ejemplo, una configuración o credenciales personalizadas de Amazon S3). El valor predeterminado es `boto3.client("s3")` si no se estableció previamente al utilizarlo por primera vez.

## Ejemplo: publicación de mensajes en Amazon SNS con carga almacenada en Amazon S3
<a name="example-s3-large-payloads-python"></a>

En el siguiente ejemplo de código, se muestra cómo:
+ Cree un tema de Amazon SNS y una cola de Amazon SQS de ejemplo.
+ Asociar la política a la cola de Amazon SQS para recibir el mensaje del tema de Amazon SNS.
+ Suscriba la cola para recibir mensajes del tema.
+ Publique un mensaje de prueba mediante el cliente extendido, el recurso temático y PlatformEndpoint el recurso de Amazon SNS.
+ La carga del mensaje se almacena en Amazon S3 y se publica la referencia a ella.
+ Imprima el mensaje publicado de la cola junto con el mensaje original recuperado de Amazon S3.

Para publicar mensajes grandes, utilice la biblioteca de clientes ampliada de Amazon SNS para Python. El mensaje que envía hace referencia a un objeto de Amazon S3 en el que se incluye el contenido real del mensaje.

```
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)
```

**Salida**

```
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
```

# Atributos de mensajes de Amazon SNS
<a name="sns-message-attributes"></a>

Amazon SNS admite los atributos de entrega de mensajes, con los que se pueden ofrecer elementos de metadatos estructurados (como marcas temporales, datos geoespaciales, firmas e identificadores) relacionados con el mensaje. En el caso de las suscripciones SQS, se puede enviar un máximo de 10 atributos de mensaje cuando se activa [Raw Message Delivery](sns-large-payload-raw-message-delivery.md) (Entrega de mensajes sin procesar). Para enviar más de 10 atributos de mensaje, debe estar desactivada la entrega de mensajes sin procesar. Los mensajes con más de 10 atributos de mensaje dirigidos a las suscripciones de Amazon SQS habilitadas para la entrega de mensajes sin procesar se descartarán como errores del cliente.

Los atributos de los mensajes son opcionales y están separados del cuerpo de los mensajes, pero se envían junto a él. El receptor puede utilizar esta información para decidir cómo gestionar el mensaje sin tener que procesar el cuerpo de este en primer lugar.

Para obtener información sobre el envío de mensajes con atributos mediante el Consola de administración de AWS o el AWS SDK para Java, consulte el [Para publicar mensajes en los temas de Amazon SNS mediante Consola de administración de AWS](sns-publishing.md#sns-publishing-messages) tutorial.

**nota**  
Los atributos de los mensajes se envían únicamente cuando la estructura de los mensajes es String, no JSON.

También puede utilizar los atributos del mensaje como ayuda para estructurar el mensaje de notificación push en los puntos de enlace móviles. En este caso, los atributos del mensaje solo se usan para ayudar a estructurar el mensaje de notificación push. Los atributos no se entregan al punto de enlace, como se entregan cuando se envían mensajes con atributos a puntos de enlace de Amazon SQS.

También puede utilizar atributos de mensajes para que sus mensajes se puedan filtrar mediante políticas de filtro de suscripciones. Puede aplicar políticas de filtro a las suscripciones de temas. Cuando se aplica una política de filtrado con el alcance de la política de filtrado establecido en `MessageAttributes` (predeterminado), una suscripción recibe solo los mensajes que tienen atributos aceptados por la política. Para obtener más información, consulte [Filtrado de mensajes en Amazon SNS](sns-message-filtering.md).

**nota**  
Cuando se utilizan atributos de mensaje para el filtrado, el valor debe ser una cadena JSON válida. De este modo, se garantiza que el mensaje se entrega a una suscripción con el filtrado de atributos de mensajes activado.

## Elementos y validación de los atributos de los mensajes
<a name="SNSMessageAttributesNTV"></a>

Cada atributo de mensaje consta de los siguientes elementos:
+ **Nombre**: el nombre del atributo de mensaje puede contener los siguientes caracteres: A-Z, a-z, 0-9, subrayado (\$1), guion (-) y punto (.). El nombre no debe comenzar ni finalizar con un punto y no debe tener dos puntos sucesivos. El nombre distingue entre mayúsculas y minúsculas y debe ser único entre todos los nombres de atributo del mensaje. El nombre puede tener una longitud de hasta 256 caracteres. El nombre no puede comenzar con `AWS.` o `Amazon.` (ni ninguna variación en el uso de mayúsculas y minúsculas), ya que estos prefijos están reservados para el uso de Amazon Web Services.
+ **Tipo**: los tipos de datos admitidos para el atributo de mensaje son `String`, `String.Array`, `Number` y `Binary`. El tipo de datos tiene las mismas restricciones en lo que respecta al contenido que el cuerpo del mensaje. Para obtener más información, consulte la sección [Tipos de datos y validación de los atributos de los mensajes](#SNSMessageAttributes.DataTypes).
+ **Valor**: el valor del atributo de mensaje especificado por el usuario. Para los tipos de datos de cadena, el atributo de valor debe seguir las mismas restricciones en lo que respecta al contenido que el cuerpo del mensaje. Sin embargo, si se utiliza el atributo de mensaje para el filtrado, el valor debe ser una cadena JSON válida para garantizar la compatibilidad con las políticas de filtrado de suscripciones de Amazon SNS. Para obtener más información, consulte la acción [Publicar](https://docs.aws.amazon.com/sns/latest/api/API_Publish.html) en la *Referencia de la API de Amazon Simple Notification Service*.

El nombre, el tipo y el valor no deben estar vacíos ni ser null. Además, el cuerpo del mensaje no debe estar vacío ni ser null. Todas las partes del atributo de mensaje, incluido el nombre, el tipo y el valor, están incluidas en la restricción de tamaño del mensaje, que actualmente es de 256 KB.

## Tipos de datos y validación de los atributos de los mensajes
<a name="SNSMessageAttributes.DataTypes"></a>

Los tipos de datos de los atributos de los mensajes identifican la forma en que Amazon SNS gestiona los valores de los atributos de los mensajes. Por ejemplo, si el tipo es un número, Amazon SNS valida que es un número.

Amazon SNS admite los siguientes tipos de datos lógicos para todos los puntos de enlace, excepto según se indica:
+ **Cadena**: las cadenas son Unicode con codificación binaria UTF-8. Para obtener una lista de los valores de código, consulte [http://en.wikipedia. org/wiki/ASCII](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters)\$1ASCII\$1printable\$1characters.
**nota**  
No se admiten valores sustitutos en los atributos de los mensajes. Por ejemplo, si se utiliza un valor sustituto para representar un emoji, se producirá el siguiente error: `Invalid attribute value was passed in for message attribute`.
+ **Cadena.matriz**: una matriz, con formato de cadena, que puede contener varios valores. Los valores pueden ser cadenas, números o las palabras clave `true`, `false` y `null`. Un String.Array de tipo numérico o booleano no requiere comillas. Los distintos valores de String.Array están separados por comas.

  Este tipo de datos no se admite en las AWS Lambda suscripciones. Si especifica este tipo de datos para los puntos de enlace de Lambda, se pasa como el tipo de datos `String` en la carga útil JSON que Amazon SNS entrega a Lambda. 
+ **Número**: los números son enteros positivos o negativos o números de coma flotante. Tienen una precisión y un rango adecuados para abarcar la mayoría de los posibles valores que los tipos integer, float y double admiten normalmente. Un número puede tener un valor comprendido entre -109 y 109, con una precisión de 5 dígitos tras el separador decimal. Los ceros iniciales y finales se recortan.

  Este tipo de datos no se admite en las AWS Lambda suscripciones. Si especifica este tipo de datos para los puntos de enlace de Lambda, se pasa como el tipo de datos `String` en la carga útil JSON que Amazon SNS entrega a Lambda. 
+ **Binario**: con los atributos de tipo binarios, se puede almacenar datos binarios de cualquier índole, tales como datos comprimidos, datos cifrados o imágenes.

## Atributos de mensaje reservados para notificaciones de inserción en móviles
<a name="sns-attrib-mobile-reserved"></a>

En la siguiente tabla se muestran los atributos de mensaje reservados para los servicios de notificación push en móviles que puede utilizar para estructurar su mensaje de notificación push: 

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/sns-message-attributes.html)

1 Apple rechazará las notificaciones de Amazon SNS si los atributos de los mensajes no cumplen sus requisitos. Para obtener más información, consulta Cómo [enviar solicitudes de notificación al APNs](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/sending_notification_requests_to_apns) sitio web para desarrolladores de Apple.

# Agrupación en lotes de mensajes de Amazon SNS
<a name="sns-batch-api-actions"></a>

## ¿Qué es la agrupación en lotes de mensajes?
<a name="what-is-message-batching"></a>

Una alternativa a la publicación de mensajes en temas estándar o FIFO mediante solicitudes de API `Publish` individuales consiste en utilizar la API `PublishBatch` de Amazon SNS para publicar hasta 10 mensajes en una única solicitud de API. Enviar los mensajes por lotes puede contribuir a reducir los costes asociados a la conexión de aplicaciones distribuidas ([mensajería A2A](sns-system-to-system-messaging.md)) o al envío de notificaciones a personas ([mensajería A2P](sns-user-notifications.md)) con Amazon SNS hasta 10 veces. Amazon SNS tiene cuotas en cuanto al número de mensajes que se pueden publicar en un tema por segundo en función de la región en la que se opere. Consulte la página [Cuotas y puntos de conexión de Amazon SNS](https://docs.aws.amazon.com/general/latest/gr/sns.html) de la guía de *Referencia general de AWS* para obtener más información sobre las cuotas de API.

**nota**  
El tamaño total agregado de todos los mensajes que se envíen en una única solicitud de API `PublishBatch` no puede superar los 262 144 bytes (256 KiB).  
La API `PublishBatch` utiliza la misma acción de API `Publish` para las políticas de IAM.

## ¿Cómo funciona la agrupación en lotes de mensajes?
<a name="message-batching-how-it-works"></a>

Publicar mensajes con la API `PublishBatch` es similar a hacerlo con la API `Publish`. La principal diferencia es que a cada mensaje de una solicitud de API `PublishBatch` se le debe asignar un ID de lote único (hasta 80 caracteres). De esta forma, Amazon SNS puede devolver respuestas de API individuales para cada mensaje de un lote, con objeto de confirmar que el mensaje se ha publicado, o bien que se ha producido un error. En el caso de los mensajes que se publiquen en temas FIFO, además de asignar un ID de lote único, se debe incluir un `MessageDeduplicationID` y un `MessageGroupId` en cada mensaje individual.

## Ejemplos
<a name="message-batching-examples"></a>

**Publicación de un lote de 10 mensajes en un tema estándar**

```
// 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<PublishBatchRequestEntry> 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());
    }
}
```

**Publicación de un lote de 10 mensajes en un tema 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<PublishBatchRequestEntry> 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());
    }
}
```

# Eliminación de un tema y una suscripción de Amazon SNS
<a name="sns-delete-subscription-topic"></a>

Cuando se elimina un tema, las suscripciones asociadas se eliminan de forma asíncrona. Aunque los clientes pueden seguir accediendo a estas suscripciones, estas ya no están asociadas al tema, aunque se vuelva a crear el tema con el mismo nombre. Si un publicador intenta publicar un mensaje en el tema eliminado, recibirá un mensaje de error que indica que el tema no existe. Del mismo modo, cualquier intento de suscribirse al tema eliminado también generará un mensaje de error. No puede eliminar una suscripción que esté pendiente de confirmación. Amazon SNS elimina automáticamente las suscripciones no confirmadas después de 48 horas, con la excepción de las suscripciones de correo electrónico, que se eliminan después de 30 días.

**importante**  
 Los temas de Amazon SNS eliminados no se pueden recuperar. Le recomendamos que elimine las suscripciones antes de eliminar un tema.   
 Una vez que se elimina la suscripción, no se puede recuperar. Las notificaciones publicadas sobre el tema de Amazon SNS no se enviarán a esa suscripción eliminada. Tendrá que volver a crear la suscripción para recibir las notificaciones. 

## Para eliminar un tema o una suscripción de Amazon SNS mediante el Consola de administración de AWS
<a name="sns-delete-subscription-topic-console"></a>

Eliminar un tema o una suscripción de Amazon SNS garantiza una administración eficaz de los recursos, ya que evita el uso de recursos innecesarios y mantiene organizada la consola de Amazon SNS. Este paso ayuda a evitar los posibles costos derivados de los recursos inactivos y optimiza la administración al eliminar los temas o las suscripciones que ya no son necesarios.

**Para eliminar un tema mediante el Consola de administración de AWS**

1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).

1. En el panel de navegación izquierdo, elija **Topics (Temas)**.

1. En la página **Temas**, seleccione un tema y, a continuación, elija **Eliminar**.

1. En el cuadro de diálogo **Eliminar tema**, ingrese `delete me` y, a continuación, elija **Eliminar**.

   La consola elimina el tema.

**Para eliminar una suscripción mediante el Consola de administración de AWS**

1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).

1. En el panel de navegación izquierdo, elija **Suscripciones**.

1. En la página **Suscripciones**, seleccione una suscripción con el estado **Confirmado** y, a continuación, elija **Eliminar**.

1. En el cuadro de diálogo **Eliminar suscripción**, elija **Eliminar**.

   La consola elimina la suscripción.

## Para eliminar una suscripción y un tema mediante un AWS SDK
<a name="delete-topic-aws-sdks"></a>

Para usar un AWS SDK, debe configurarlo con sus credenciales. Para obtener más información, consulte [Los archivos de configuración y credenciales compartidos](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) en la *Guía de referencia de herramientas AWS SDKs y herramientas*.

Los siguientes ejemplos de código muestran cómo utilizar `DeleteTopic`.

------
#### [ .NET ]

**SDK para .NET**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/TopicsAndQueues#code-examples). 
Elimine un tema por su ARN de tema.  

```
    /// <summary>
    /// Delete a topic by its topic ARN.
    /// </summary>
    /// <param name="topicArn">The ARN of the topic.</param>
    /// <returns>True if successful.</returns>
    public async Task<bool> DeleteTopicByArn(string topicArn)
    {
        var deleteResponse = await _amazonSNSClient.DeleteTopicAsync(
            new DeleteTopicRequest()
            {
                TopicArn = topicArn
            });
        return deleteResponse.HttpStatusCode == HttpStatusCode.OK;
    }
```
+  Para obtener más información sobre la API, consulta [DeleteTopic](https://docs.aws.amazon.com/goto/DotNetSDKV3/sns-2010-03-31/DeleteTopic)la *Referencia AWS SDK para .NET de la API*. 

------
#### [ C\$1\$1 ]

**SDK para C\$1\$1**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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();
}
```
+  Para obtener más información sobre la API, consulta [DeleteTopic](https://docs.aws.amazon.com/goto/SdkForCpp/sns-2010-03-31/DeleteTopic)la *Referencia AWS SDK para C\$1\$1 de la API*. 

------
#### [ CLI ]

**AWS CLI**  
**Eliminación de un tema de SNS**  
El siguiente ejemplo de `delete-topic` elimina el tema de SNS especificado.  

```
aws sns delete-topic \
    --topic-arn "arn:aws:sns:us-west-2:123456789012:my-topic"
```
Este comando no genera ninguna salida.  
+  Para obtener más información sobre la API, consulta [DeleteTopic](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/delete-topic.html)la *Referencia de AWS CLI comandos*. 

------
#### [ Go ]

**SDK para Go V2**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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
}
```
+  Para obtener más información sobre la API, consulta [DeleteTopic](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sns#Client.DeleteTopic)la *Referencia AWS SDK para Go de la API*. 

------
#### [ Java ]

**SDK para Java 2.x**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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:     <topicArn>

                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);
        }
    }
}
```
+  Para obtener más información sobre la API, consulta [DeleteTopic](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/DeleteTopic)la *Referencia AWS SDK for Java 2.x de la API*. 

------
#### [ JavaScript ]

**SDK para JavaScript (v3)**  
 Hay más información. GitHub Busque el ejemplo completo y aprenda a configurarlo y ejecutarlo en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sns#code-examples). 
Cree el cliente en un módulo separado y expórtelo.  

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```
Importe el SDK y los módulos cliente, y llame a la 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
  //   }
  // }
};
```
+  Para obtener información, consulte la [Guía para desarrolladores de AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-managing-topics.html#sns-examples-managing-topics-deletetopic). 
+  Para obtener más información sobre la API, consulta [DeleteTopic](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/DeleteTopicCommand)la *Referencia AWS SDK para JavaScript de la API*. 

------
#### [ Kotlin ]

**SDK para Kotlin**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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.")
    }
}
```
+  Para obtener más información sobre la API, consulta [DeleteTopic](https://sdk.amazonaws.com/kotlin/api/latest/index.html)la *referencia sobre el AWS SDK para la API de Kotlin*. 

------
#### [ PHP ]

**SDK para PHP**  
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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());
}
```
+  Para obtener más información sobre la API, consulta [DeleteTopic](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/DeleteTopic)la *Referencia AWS SDK para PHP de la API*. 

------
#### [ Python ]

**SDK para Python (Boto3)**  
 Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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
```
+  Para obtener más información sobre la API, consulta [DeleteTopic](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/DeleteTopic)la *AWS Referencia de API de SDK for Python (Boto3*). 

------
#### [ SAP ABAP ]

**SDK para SAP ABAP**  
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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.
```
+  Para obtener más información sobre la API, consulte [DeleteTopic](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la *referencia sobre la API ABAP del AWS SDK para SAP*. 

------
#### [ Swift ]

**SDK para Swift**  
 Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de 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)
        )
```
+  Para obtener más información sobre la API, consulta [DeleteTopic](https://sdk.amazonaws.com/swift/api/awssns/latest/documentation/awssns/snsclient/deletetopic(input:))la *referencia sobre la API de AWS SDK for Swift*. 

------

# Siguientes pasos
<a name="sns-next-steps-getting-started"></a>

Ahora que ha creado un tema con una suscripción y enviado mensajes a este, es posible que desee probar lo siguiente:
+ Explore el [Centro de desarrolladores de AWS](https://aws.amazon.com/developer/).
+ Obtenga información sobre la protección de los datos en la sección [Seguridad](security.md).
+ Habilite el [cifrado en el servidor](sns-enable-encryption-for-topic.md) para un tema.
+ Habilite el cifrado en el lado de servidor para un tema con [ una cola suscrita de Amazon Simple Queue Service (Amazon SQS) cifrada](sns-enable-encryption-for-topic-sqs-queue-subscriptions.md).
+ Suscriba [Canalizaciones de bifurcación de eventos de AWS](sns-subscribe-event-fork-pipelines.md) a un tema.