La [AWS SDK per JavaScript V3 API Reference Guide](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) descrive in dettaglio tutte le operazioni API per la AWS SDK per JavaScript versione 3 (V3).
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esempi di servizi di notifica Amazon Simple
Amazon Simple Notification Service (Amazon SNS) è un servizio Web che coordina e gestisce la consegna o l'invio di messaggi a endpoint o client abbonati.
In Amazon SNS, esistono due tipi di clienti, editori e abbonati, noti anche come produttori e consumatori.
![\[Relazione tra JavaScript ambienti, SDK e Amazon SNS\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/code-samples-sns.png)
Gli editori comunicano in modo asincrono con i sottoscrittori producendo e inviando un messaggio a un argomento, che rappresenta un punto di accesso logico e un canale di comunicazione. Gli abbonati (server Web, indirizzi e-mail, code Amazon SQS AWS Lambda , funzioni) utilizzano o ricevono il messaggio o la notifica tramite uno dei protocolli supportati (Amazon SQS, HTTP/S, e-mail AWS Lambda, SMS) quando sono abbonati all'argomento.
L' JavaScript API per Amazon SNS è esposta tramite la [classe:](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SNS/) SNS.
**Topics**
+ [Gestione degli argomenti in Amazon SNS](sns-examples-managing-topics.md)
+ [Pubblicazione di messaggi in Amazon SNS](sns-examples-publishing-messages.md)
+ [Gestione degli abbonamenti in Amazon SNS](sns-examples-subscribing-unsubscribing-topics.md)
+ [Invio di messaggi SMS con Amazon SNS](sns-examples-sending-sms.md)
# Gestione degli argomenti in Amazon SNS
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Questo esempio di codice di Node.js illustra:**
+ Come creare argomenti in Amazon SNS su cui pubblicare notifiche.
+ Come eliminare argomenti creati in Amazon SNS.
+ Come ottenere un elenco degli argomenti disponibili.
+ Come ottenere e impostare gli attributi di argomento.
## Lo scenario
In questo esempio, utilizzi una serie di moduli Node.js per creare, elencare ed eliminare argomenti di Amazon SNS e per gestire gli attributi degli argomenti. I moduli Node.js utilizzano l'SDK per JavaScript gestire gli argomenti utilizzando questi metodi della classe `SNS` client:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CreateTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CreateTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListTopicsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListTopicsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/DeleteTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/DeleteTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetTopicAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetTopicAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetTopicAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetTopicAttributesCommand/)
## Attività prerequisite
Per configurare ed eseguire questo esempio, è necessario completare queste attività:
+ Configura l'ambiente di progetto per eseguire questi TypeScript esempi di Node e installa i moduli richiesti AWS SDK per JavaScript e di terze parti. Segui le istruzioni su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Creazione di un file di configurazione condiviso con le credenziali utente. Per ulteriori informazioni sulla fornitura di un file di credenziali condiviso, consulta File di [configurazione e credenziali condivisi nella AWS SDKs and](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) *Tools* Reference Guide.
**Importante**
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)
## Creazione di un argomento
In questo esempio, usa un modulo Node.js per creare un argomento Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `create-topic.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.
Crea un oggetto per trasferire l'oggetto `Name` per il nuovo argomento al metodo `CreateTopicCommand` della classe client `SNS`. Per chiamare il `CreateTopicCommand` metodo, crea una funzione asincrona che richiama un oggetto di servizio Amazon SNS, passando l'oggetto parameters. Il `data` valore restituito contiene l'ARN dell'argomento.
**Nota**
Sostituisci *TOPIC\$1NAME* con il nome dell'argomento.
```
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;
};
```
Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.
```
node create-topic.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/create-topic.js).
## Elenco dei tuoi argomenti
In questo esempio, usa un modulo Node.js per elencare tutti gli argomenti di Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `list-topics.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.
Crea un oggetto vuoto da trasferire al metodo `ListTopicsCommand` della classe client `SNS`. Per chiamare il `ListTopicsCommand` metodo, crea una funzione asincrona che richiama un oggetto di servizio Amazon SNS, passando l'oggetto parameters. Il file `data` restituito contiene una matrice del tuo argomento Amazon Resource Names (ARNs).
```
import { ListTopicsCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
export const listTopics = async () => {
const response = await snsClient.send(new ListTopicsCommand({}));
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '936bc5ad-83ca-53c2-b0b7-9891167b909e',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// Topics: [ { TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:mytopic' } ]
// }
return response;
};
```
Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.
```
node list-topics.js
```
Questo codice di esempio è disponibile [qui](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-topics.js). GitHub
## Eliminazione di un argomento
In questo esempio, usa un modulo Node.js per eliminare un argomento di Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `delete-topic.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.
Crea un oggetto contenente il parametro `TopicArn` dell'argomento da eliminare per passare al metodo `DeleteTopicCommand` della classe client `SNS`. Per chiamare il `DeleteTopicCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters.
**Nota**
Sostituisci *TOPIC\$1ARN* con l'Amazon Resource Name (ARN) dell'argomento che stai eliminando.
```
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
// }
// }
};
```
Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.
```
node delete-topic.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/delete-topic.js).
## Recupero degli attributi di argomento
In questo esempio, usa un modulo Node.js per recuperare gli attributi di un argomento Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `get-topic-attributes.js`. Configura l'SDK come mostrato in precedenza.
Crea un oggetto contenente il parametro `TopicArn` di un argomento da eliminare per passare al metodo `GetTopicAttributesCommand` della classe client `SNS`. Per chiamare il `GetTopicAttributesCommand` metodo, è necessario richiamare un oggetto del servizio client Amazon SNS, passare l'oggetto parameters.
**Nota**
Sostituisci *TOPIC\$1ARN* con l'ARN dell'argomento.
```
import { GetTopicAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string} topicArn - The ARN of the topic to retrieve attributes for.
*/
export const getTopicAttributes = async (topicArn = "TOPIC_ARN") => {
const response = await snsClient.send(
new GetTopicAttributesCommand({
TopicArn: topicArn,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '36b6a24e-5473-5d4e-ac32-ff72d9a73d94',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// Attributes: {
// Policy: '{...}',
// Owner: 'xxxxxxxxxxxx',
// SubscriptionsPending: '1',
// TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:mytopic',
// TracingConfig: 'PassThrough',
// EffectiveDeliveryPolicy: '{"http":{"defaultHealthyRetryPolicy":{"minDelayTarget":20,"maxDelayTarget":20,"numRetries":3,"numMaxDelayRetries":0,"numNoDelayRetries":0,"numMinDelayRetries":0,"backoffFunction":"linear"},"disableSubscriptionOverrides":false,"defaultRequestPolicy":{"headerContentType":"text/plain; charset=UTF-8"}}}',
// SubscriptionsConfirmed: '0',
// DisplayName: '',
// SubscriptionsDeleted: '1'
// }
// }
return response;
};
```
Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.
```
node get-topic-attributes.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/get-topic-attributes.js).
## Impostazione degli attributi di argomento
In questo esempio, usa un modulo Node.js per impostare gli attributi mutabili di un argomento Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `set-topic-attributes.js`. Configura l'SDK come mostrato in precedenza.
Crea un oggetto contenente i parametri per l'aggiornamento dell'attributo, inclusi il parametro `TopicArn` dell'argomento di cui desideri impostare gli attributi, il nome dell'attributo da impostare e il nuovo valore per l'attributo. È possibile impostare solo gli attributi `Policy`, `DisplayName` e `DeliveryPolicy`. Trasferisci i parametri al metodo `SetTopicAttributesCommand` della classe client `SNS`. Per chiamare il `SetTopicAttributesCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters.
**Nota**
Sostituisci *ATTRIBUTE\$1NAME* con il nome dell'attributo che stai impostando, *TOPIC\$1ARN* con l'Amazon Resource Name (ARN) dell'argomento di cui desideri impostare gli attributi e *NEW\$1ATTRIBUTE\$1VALUE* con il nuovo valore per quell'attributo.
```
import { SetTopicAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
export const setTopicAttributes = async (
topicArn = "TOPIC_ARN",
attributeName = "DisplayName",
attributeValue = "Test Topic",
) => {
const response = await snsClient.send(
new SetTopicAttributesCommand({
AttributeName: attributeName,
AttributeValue: attributeValue,
TopicArn: topicArn,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: 'd1b08d0e-e9a4-54c3-b8b1-d03238d2b935',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// }
// }
return response;
};
```
Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.
```
node set-topic-attributes.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-topic-attributes.js).
# Pubblicazione di messaggi in Amazon SNS
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Questo esempio di codice di Node.js illustra:**
+ Come pubblicare messaggi su un argomento di Amazon SNS.
## Lo scenario
In questo esempio, utilizzi una serie di moduli Node.js per pubblicare messaggi da Amazon SNS su endpoint, e-mail o numeri di telefono tematici. I moduli Node.js utilizzano l'SDK per JavaScript inviare messaggi utilizzando questo metodo della `SNS` classe client:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/)
## Attività prerequisite
Per configurare ed eseguire questo esempio, è necessario completare queste attività:
+ Configura l'ambiente di progetto per eseguire questi TypeScript esempi di Node e installa i moduli richiesti AWS SDK per JavaScript e di terze parti. Segui le istruzioni su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Creazione di un file di configurazione condiviso con le credenziali utente. Per ulteriori informazioni sulla fornitura di un file di credenziali condiviso, consulta File di [configurazione e credenziali condivisi nella AWS SDKs and](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) *Tools* Reference Guide.
**Importante**
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)
## Pubblicazione di un messaggio in un argomento SNS
In questo esempio, usa un modulo Node.js per pubblicare un messaggio su un argomento di Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `publish-topic.js`. Configura l'SDK come mostrato in precedenza.
Crea un oggetto contenente i parametri per la pubblicazione di un messaggio, incluso il testo del messaggio e l'Amazon Resource Name (ARN) di Amazon. SNStopic Per i dettagli sugli attributi SMS disponibili, consulta [Set SMSAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SNS.html#setSMSAttributes-property).
Passa i parametri al `PublishCommand` metodo della classe `SNS` client. Crea una funzione asincrona richiamando un oggetto del servizio client Amazon SNS, passando l'oggetto parameters.
**Nota**
Sostituisci *MESSAGE\$1TEXT* con il testo del messaggio e *TOPIC\$1ARN* con l'ARN dell'argomento SNS.
```
import { PublishCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string | Record} message - The message to send. Can be a plain string or an object
* if you are using the `json` `MessageStructure`.
* @param {string} topicArn - The ARN of the topic to which you would like to publish.
*/
export const publish = async (
message = "Hello from SNS!",
topicArn = "TOPIC_ARN",
) => {
const response = await snsClient.send(
new PublishCommand({
Message: message,
TopicArn: topicArn,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: 'e7f77526-e295-5325-9ee4-281a43ad1f05',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// MessageId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
// }
return response;
};
```
Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.
```
node publish-topic.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/publish-topic.js).
# Gestione degli abbonamenti in Amazon SNS
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Questo esempio di codice di Node.js illustra:**
+ Come elencare tutti gli abbonamenti a un argomento di Amazon SNS.
+ Come sottoscrivere un indirizzo e-mail, un endpoint dell'applicazione o una AWS Lambda funzione a un argomento di Amazon SNS.
+ Come annullare l'iscrizione agli argomenti di Amazon SNS.
## Lo scenario
In questo esempio, utilizzi una serie di moduli Node.js per pubblicare messaggi di notifica su argomenti di Amazon SNS. I moduli Node.js utilizzano l'SDK per JavaScript gestire gli argomenti utilizzando questi metodi della classe `SNS` client:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListSubscriptionsByTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListSubscriptionsByTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SubscribeCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SubscribeCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ConfirmSubscriptionCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ConfirmSubscriptionCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/UnsubscribeCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/UnsubscribeCommand/)
## Attività prerequisite
Per configurare ed eseguire questo esempio, è necessario completare queste attività:
+ Configura l'ambiente di progetto per eseguire questi TypeScript esempi di Node e installa i moduli richiesti AWS SDK per JavaScript e di terze parti. Segui le istruzioni su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Creazione di un file di configurazione condiviso con le credenziali utente. Per ulteriori informazioni sulla fornitura di un file di credenziali condiviso, consulta File di [configurazione e credenziali condivisi nella AWS SDKs and](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) *Tools* Reference Guide.
**Importante**
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)
## Elenco di sottoscrizioni a un argomento
In questo esempio, usa un modulo Node.js per elencare tutte le sottoscrizioni a un argomento di Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `list-subscriptions-by-topic.js`. Configura l'SDK come mostrato in precedenza.
Crea un oggetto contenente il parametro `TopicArn` per l'argomento di cui si desideri elencare le sottoscrizioni. Trasferisci i parametri al metodo `ListSubscriptionsByTopicCommand` della classe client `SNS`. Per chiamare il `ListSubscriptionsByTopicCommand` metodo, crea una funzione asincrona che richiama un oggetto servizio client Amazon SNS e passa l'oggetto parameters.
**Nota**
Sostituisci *TOPIC\$1ARN* con Amazon Resource Name (ARN) per l'argomento di cui desideri elencare gli abbonamenti.
```
import { ListSubscriptionsByTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string} topicArn - The ARN of the topic for which you wish to list subscriptions.
*/
export const listSubscriptionsByTopic = async (topicArn = "TOPIC_ARN") => {
const response = await snsClient.send(
new ListSubscriptionsByTopicCommand({ TopicArn: topicArn }),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '0934fedf-0c4b-572e-9ed2-a3e38fadb0c8',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// Subscriptions: [
// {
// SubscriptionArn: 'PendingConfirmation',
// Owner: '901487484989',
// Protocol: 'email',
// Endpoint: 'corepyle@amazon.com',
// TopicArn: 'arn:aws:sns:us-east-1:901487484989:mytopic'
// }
// ]
// }
return response;
};
```
Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.
```
node list-subscriptions-by-topic.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-subscriptions-by-topic.js).
## Sottoscrizione di un indirizzo e-mail a un argomento
In questo esempio, usa un modulo Node.js per iscrivere un indirizzo e-mail in modo che riceva messaggi e-mail SMTP da un argomento di Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `subscribe-email.js`. Configura l'SDK come mostrato in precedenza.
Crea un oggetto contenente il parametro `Protocol` per specificare il protocollo `email`, il parametro `TopicArn` per l'argomento a cui effettuare la sottoscrizione e un indirizzo e-mail come `Endpoint` del messaggio. Trasferisci i parametri al metodo `SubscribeCommand` della classe client `SNS`. Puoi utilizzare il `subscribe` metodo per sottoscrivere diversi endpoint a un argomento Amazon SNS, a seconda dei valori utilizzati per i parametri passati, come mostreranno altri esempi in questo argomento.
Per chiamare il `SubscribeCommand` metodo, crea una funzione asincrona che richiama un oggetto servizio client Amazon SNS e passa l'oggetto parameters.
**Nota**
Sostituisci *TOPIC\$1ARN* con l'Amazon Resource Name (ARN) per l'argomento e *EMAIL\$1ADDRESS* con l'indirizzo e-mail a cui iscriverti.
```
import { SubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string} topicArn - The ARN of the topic for which you wish to confirm a subscription.
* @param {string} emailAddress - The email address that is subscribed to the topic.
*/
export const subscribeEmail = async (
topicArn = "TOPIC_ARN",
emailAddress = "usern@me.com",
) => {
const response = await snsClient.send(
new SubscribeCommand({
Protocol: "email",
TopicArn: topicArn,
Endpoint: emailAddress,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: 'c8e35bcd-b3c0-5940-9f66-06f6fcc108f0',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// SubscriptionArn: 'pending confirmation'
// }
};
```
Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.
```
node subscribe-email.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-email.js).
### Conferma delle sottoscrizioni
In questo esempio, utilizzate un modulo Node.js per verificare l'intenzione del proprietario di un endpoint di ricevere e-mail convalidando il token inviato all'endpoint con una precedente azione di sottoscrizione.
Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `confirm-subscription.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.
Definite i parametri, incluso `TOPIC_ARN` e`TOKEN`, e definite un valore di `TRUE` o `FALSE` per`AuthenticateOnUnsubscribe`.
Il token è un token di breve durata inviato al proprietario di un endpoint durante un'azione precedente`SUBSCRIBE`. Ad esempio, per un endpoint di posta elettronica, `TOKEN` si trova nell'URL dell'e-mail di conferma dell'iscrizione inviata al proprietario dell'e-mail. Ad esempio, `abc123` è il token nel seguente URL.
![\[Amazon Web Services Simple Notification Service subscription confirmation page.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/token.png)
Per chiamare il `ConfirmSubscriptionCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters.
**Nota**
Sostituisci *TOPIC\$1ARN* con l'Amazon Resource Name (ARN) per l'argomento, *TOKEN* con il valore del token dell'URL inviato al proprietario dell'endpoint in un'`Subscribe`azione precedente e definisci*AuthenticateOnUnsubscribe*. con il valore o. `TRUE` `FALSE`
```
import { ConfirmSubscriptionCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string} token - This token is sent the subscriber. Only subscribers
* that are not AWS services (HTTP/S, email) need to be confirmed.
* @param {string} topicArn - The ARN of the topic for which you wish to confirm a subscription.
*/
export const confirmSubscription = async (
token = "TOKEN",
topicArn = "TOPIC_ARN",
) => {
const response = await snsClient.send(
// A subscription only needs to be confirmed if the endpoint type is
// HTTP/S, email, or in another AWS account.
new ConfirmSubscriptionCommand({
Token: token,
TopicArn: topicArn,
// If this is true, the subscriber cannot unsubscribe while unauthenticated.
AuthenticateOnUnsubscribe: "false",
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '4bb5bce9-805a-5517-8333-e1d2cface90b',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// SubscriptionArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:TOPIC_NAME:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
// }
return response;
};
```
Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.
```
node confirm-subscription.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/confirm-subscription.js).
## Sottoscrizione di un endpoint di applicazione a un argomento
In questo esempio, usa un modulo Node.js per sottoscrivere un endpoint di applicazione mobile in modo che riceva notifiche da un argomento di Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `subscribe-app.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei moduli e dei pacchetti richiesti.
Crea un oggetto contenente il `Protocol` parametro `TopicArn` per specificare il `application` protocollo, l'argomento a cui sottoscrivere e l'Amazon Resource Name (ARN) di un endpoint di applicazione mobile per il parametro. `Endpoint` Trasferisci i parametri al metodo `SubscribeCommand` della classe client `SNS`.
Per chiamare il `SubscribeCommand` metodo, crea una funzione asincrona che richiama un oggetto di servizio Amazon SNS, passando l'oggetto parameters.
**Nota**
Sostituiscilo *TOPIC\$1ARN* con l'Amazon Resource Name (ARN) per l'argomento e *MOBILE\$1ENDPOINT\$1ARN* con l'endpoint a cui ti stai abbonando all'argomento.
```
import { SubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string} topicArn - The ARN of the topic the subscriber is subscribing to.
* @param {string} endpoint - The Endpoint ARN of an application. This endpoint is created
* when an application registers for notifications.
*/
export const subscribeApp = async (
topicArn = "TOPIC_ARN",
endpoint = "ENDPOINT",
) => {
const response = await snsClient.send(
new SubscribeCommand({
Protocol: "application",
TopicArn: topicArn,
Endpoint: endpoint,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: 'c8e35bcd-b3c0-5940-9f66-06f6fcc108f0',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// SubscriptionArn: 'pending confirmation'
// }
return response;
};
```
Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.
```
node subscribe-app.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-app.js).
## Sottoscrizione di una funzione Lambda a un argomento
In questo esempio, usa un modulo Node.js per sottoscrivere una AWS Lambda funzione in modo che riceva notifiche da un argomento di Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `subscribe-lambda.js`. Configura l'SDK come mostrato in precedenza.
Crea un oggetto contenente il `Protocol` parametro, specificando il `lambda` protocollo, l'`TopicArn`argomento a cui sottoscrivere e l'Amazon Resource Name (ARN) di AWS Lambda una funzione come `Endpoint` parametro. Trasferisci i parametri al metodo `SubscribeCommand` della classe client `SNS`.
Per chiamare il `SubscribeCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters.
**Nota**
Sostituisci *TOPIC\$1ARN* con Amazon Resource Name (ARN) per l'argomento e *LAMBDA\$1FUNCTION\$1ARN* con Amazon Resource Name (ARN) della funzione Lambda.
```
import { SubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string} topicArn - The ARN of the topic the subscriber is subscribing to.
* @param {string} endpoint - The Endpoint ARN of and AWS Lambda function.
*/
export const subscribeLambda = async (
topicArn = "TOPIC_ARN",
endpoint = "ENDPOINT",
) => {
const response = await snsClient.send(
new SubscribeCommand({
Protocol: "lambda",
TopicArn: topicArn,
Endpoint: endpoint,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: 'c8e35bcd-b3c0-5940-9f66-06f6fcc108f0',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// SubscriptionArn: 'pending confirmation'
// }
return response;
};
```
Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.
```
node subscribe-lambda.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-lambda.js).
## Annullamento della sottoscrizione a un argomento
In questo esempio, usa un modulo Node.js per annullare l'iscrizione a un argomento Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome del file. `snsClient.js` Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `unsubscribe.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti.
Crea un oggetto contenente il `SubscriptionArn` parametro, specificando l'Amazon Resource Name (ARN) dell'abbonamento per annullare l'iscrizione. Trasferisci i parametri al metodo `UnsubscribeCommand` della classe client `SNS`.
Per chiamare il `UnsubscribeCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters.
**Nota**
Sostituisci *TOPIC\$1SUBSCRIPTION\$1ARN* con l'Amazon Resource Name (ARN) dell'abbonamento per annullare l'iscrizione.
```
import { UnsubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string} subscriptionArn - The ARN of the subscription to cancel.
*/
const unsubscribe = async (
subscriptionArn = "arn:aws:sns:us-east-1:xxxxxxxxxxxx:mytopic:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
) => {
const response = await snsClient.send(
new UnsubscribeCommand({
SubscriptionArn: subscriptionArn,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '0178259a-9204-507c-b620-78a7570a44c6',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// }
// }
return response;
};
```
Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.
```
node unsubscribe.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/unsubscribe.js).
# Invio di messaggi SMS con Amazon SNS
![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)
**Questo esempio di codice di Node.js illustra:**
+ Come ottenere e impostare le preferenze di messaggistica SMS per Amazon SNS.
+ Come controllare un numero di telefono per verificare se è stata disattivata la ricezione di messaggi SMS.
+ Come ottenere un elenco di numeri di telefono per cui è stata disattivata la ricezione di messaggi SMS.
+ Come inviare un messaggio SMS.
## Lo scenario
Puoi utilizzare Amazon SNS; per inviare messaggi SMS a dispositivi abilitati. Puoi inviare un messaggio direttamente a un numero di telefono oppure inviarlo a più numeri contemporaneamente sottoscrivendo quei numeri a un argomento e inviando il messaggio all'argomento.
In questo esempio, utilizzi una serie di moduli Node.js per pubblicare messaggi di testo SMS da Amazon SNS a dispositivi abilitati agli SMS. I moduli Node.js utilizzano l'SDK per JavaScript pubblicare messaggi SMS utilizzando questi metodi della classe client: `SNS`
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetSMSAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetSMSAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetSMSAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetSMSAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CheckIfPhoneNumberIsOptedOutCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CheckIfPhoneNumberIsOptedOutCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListPhoneNumbersOptedOutCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListPhoneNumbersOptedOutCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/)
## Attività prerequisite
Per configurare ed eseguire questo esempio, è necessario completare queste attività:
+ Configura l'ambiente di progetto per eseguire questi TypeScript esempi di Node e installa i moduli richiesti AWS SDK per JavaScript e di terze parti. Segui le istruzioni su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Creazione di un file di configurazione condiviso con le credenziali utente. Per ulteriori informazioni sulla fornitura di un file di credenziali condiviso, consulta File di [configurazione e credenziali condivisi nella AWS SDKs and](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) *Tools* Reference Guide.
**Importante**
Questi esempi mostrano come import/export client gli oggetti e i comandi del servizio utilizzando ECMAScript6 (). ES6
Ciò richiede la versione 13.x o successiva di Node.js. Per scaricare e installare la versione più recente di Node.js, consulta [Node.js downloads](https://nodejs.org/en/download). .
Se preferisci usare la sintassi CommonJS, vedi. [JavaScript ES6Sintassi /CommonJS](sdk-example-javascript-syntax.md)
## Recupero degli attributi SMS
Usa Amazon SNS per specificare le preferenze per la messaggistica SMS, ad esempio il modo in cui le consegne sono ottimizzate (in termini di costi o per una consegna affidabile), il limite di spesa mensile, il modo in cui vengono registrate le consegne dei messaggi e se abbonarsi ai report giornalieri sull'utilizzo degli SMS. Queste preferenze vengono recuperate e impostate come attributi SMS per Amazon SNS.
In questo esempio, usa un modulo Node.js per ottenere gli attributi SMS correnti in Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `get-sms-attributes.js`.
Configura l'SDK come mostrato in precedenza, incluso il download dei client e dei pacchetti richiesti. Crea un oggetto contenente i parametri per ottenere attributi SMS, inclusi i nomi dei singoli attributi da recuperare. Per i dettagli sugli attributi SMS disponibili, consulta [Set SMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) in the Amazon Simple Notification Service API Reference.
Questo esempio recupera l'attributo `DefaultSMSType`, che controlla se i messaggi SMS vengono inviati come `Promotional` per ottimizzare il recapito dei messaggi e permettere di contenere i costi, oppure come `Transactional` per ottimizzare il recapito dei messaggi e ottenere la massima affidabilità. Trasferisci i parametri al metodo `SetTopicAttributesCommand` della classe client `SNS`. Per chiamare il `SetSMSAttributesCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters.
**Nota**
Sostituisci *ATTRIBUTE\$1NAME* con il nome dell'attributo.
```
import { GetSMSAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
export const getSmsAttributes = async () => {
const response = await snsClient.send(
// If you have not modified the account-level mobile settings of SNS,
// the DefaultSMSType is undefined. For this example, it was set to
// Transactional.
new GetSMSAttributesCommand({ attributes: ["DefaultSMSType"] }),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '67ad8386-4169-58f1-bdb9-debd281d48d5',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// attributes: { DefaultSMSType: 'Transactional' }
// }
return response;
};
```
Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.
```
node get-sms-attributes.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/get-sms-attributes.js).
## Impostazione degli attributi SMS
In questo esempio, usa un modulo Node.js per ottenere gli attributi SMS correnti in Amazon SNS.
Crea una `libs` directory e crea un modulo Node.js con il nome `snsClient.js` del file. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `set-sms-attribute-type.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Crea un oggetto contenente i parametri per impostare gli attributi SMS, inclusi i nomi dei singoli attributi da impostare e i valori da impostare per ciascuno di essi. Per i dettagli sugli attributi SMS disponibili, consulta [Set SMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) in the Amazon Simple Notification Service API Reference.
Questo esempio imposta l'attributo `DefaultSMSType` su `Transactional`, ottimizzando il recapito dei messaggi per ottenere la massima affidabilità. Trasferisci i parametri al metodo `SetTopicAttributesCommand` della classe client `SNS`. Per chiamare il `SetSMSAttributesCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters.
```
import { SetSMSAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {"Transactional" | "Promotional"} defaultSmsType
*/
export const setSmsType = async (defaultSmsType = "Transactional") => {
const response = await snsClient.send(
new SetSMSAttributesCommand({
attributes: {
// Promotional – (Default) Noncritical messages, such as marketing messages.
// Transactional – Critical messages that support customer transactions,
// such as one-time passcodes for multi-factor authentication.
DefaultSMSType: defaultSmsType,
},
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '1885b977-2d7e-535e-8214-e44be727e265',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// }
// }
return response;
};
```
Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.
```
node set-sms-attribute-type.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-sms-attribute-type.js).
## Controllare se un numero di telefono è stato disattivato
In questo esempio, utilizza un modulo Node.js per controllare un numero di telefono per verificare se è stata disattivata la ricezione di messaggi SMS.
Crea una `libs` directory e crea un modulo Node.js con il nome del file`snsClient.js`. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `check-if-phone-number-is-opted-out.js`. Configura l'SDK come mostrato in precedenza. Crea un oggetto contenente il numero di telefono da controllare come parametro.
Questo esempio imposta il parametro `PhoneNumber` per specificare il numero di telefono da verificare. Trasferisci l'oggetto al metodo `CheckIfPhoneNumberIsOptedOutCommand` della classe client `SNS`: Per chiamare il `CheckIfPhoneNumberIsOptedOutCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters.
**Nota**
Sostituisci con il numero *PHONE\$1NUMBER* di telefono.
```
import { CheckIfPhoneNumberIsOptedOutCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
export const checkIfPhoneNumberIsOptedOut = async (
phoneNumber = "5555555555",
) => {
const command = new CheckIfPhoneNumberIsOptedOutCommand({
phoneNumber,
});
const response = await snsClient.send(command);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '3341c28a-cdc8-5b39-a3ee-9fb0ee125732',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// isOptedOut: false
// }
return response;
};
```
Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.
```
node check-if-phone-number-is-opted-out.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/check-if-phone-number-is-opted-out.js).
## Elenco di numeri di telefono disattivati
In questo esempio, utilizza un modulo Node.js per ottenere un elenco di numeri di telefono per cui è stata disattivata la ricezione di messaggi SMS.
Crea una `libs` directory e crea un modulo Node.js con il nome del file`snsClient.js`. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `list-phone-numbers-opted-out.js`. Configura l'SDK come mostrato in precedenza. Crea un oggetto vuoto come parametro.
Trasferisci l'oggetto al metodo `ListPhoneNumbersOptedOutCommand` della classe client `SNS`: Per chiamare il `ListPhoneNumbersOptedOutCommand` metodo, crea una funzione asincrona che richiama un oggetto del servizio client Amazon SNS, passando l'oggetto parameters.
```
import { ListPhoneNumbersOptedOutCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
export const listPhoneNumbersOptedOut = async () => {
const response = await snsClient.send(
new ListPhoneNumbersOptedOutCommand({}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '44ff72fd-1037-5042-ad96-2fc16601df42',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// phoneNumbers: ['+15555550100']
// }
return response;
};
```
Per eseguire l'esempio, inserisci quanto segue al prompt dei comandi.
```
node list-phone-numbers-opted-out.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-phone-numbers-opted-out.js).
## Pubblicazione di un messaggio SMS
In questo esempio, utilizza un modulo Node.js per inviare un messaggio SMS a un numero di telefono.
Crea una `libs` directory e crea un modulo Node.js con il nome del file`snsClient.js`. Copia e incolla il codice seguente al suo interno, per creare l'oggetto client Amazon SNS. *REGION*Sostituiscilo con la tua AWS regione.
```
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({});
```
Questo codice di esempio può essere trovato [qui GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).
Crea un modulo Node.js con il nome del file `publish-sms.js`. Configura l'SDK come mostrato in precedenza, inclusa l'installazione dei client e dei pacchetti richiesti. Crea un oggetto contenente i parametri `Message` e `PhoneNumber`.
Quando invii un SMS, ricorda di specificare il numero di telefono utilizzando il formato E.164. E.164 è uno standard per la struttura del numero di telefono utilizzato per le telecomunicazioni internazionali. I numeri di telefono che seguono questo formato possono avere un massimo di 15 cifre e sono preceduti dal segno più (\$1) e dal prefisso internazionale. Ad esempio, un numero di telefono statunitense in formato E.164 apparirebbe come \$11001. XXX5550100
Questo esempio imposta il parametro `PhoneNumber` per specificare il numero di telefono a cui inviare il messaggio. Trasferisci l'oggetto al metodo `PublishCommand` della classe client `SNS`: Per chiamare il `PublishCommand` metodo, crea una funzione asincrona che richiama un oggetto di servizio Amazon SNS, passando l'oggetto parameters.
**Nota**
Sostituisci *TEXT\$1MESSAGE* con il messaggio di testo e *PHONE\$1NUMBER* con il numero di telefono.
```
import { PublishCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string | Record} message - The message to send. Can be a plain string or an object
* if you are using the `json` `MessageStructure`.
* @param {*} phoneNumber - The phone number to send the message to.
*/
export const publish = async (
message = "Hello from SNS!",
phoneNumber = "+15555555555",
) => {
const response = await snsClient.send(
new PublishCommand({
Message: message,
// One of PhoneNumber, TopicArn, or TargetArn must be specified.
PhoneNumber: phoneNumber,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '7410094f-efc7-5f52-af03-54737569ab77',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// MessageId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
// }
return response;
};
```
Per eseguire l'esempio, immettere quanto segue al prompt dei comandi.
```
node publish-sms.js
```
Questo codice di esempio è disponibile [qui su GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/publish-sms.js).