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à.
# Tutorial: Utilizzo AWS Lambda con Amazon Simple Notification Service
In questo tutorial, utilizzi una funzione Lambda in un'unica funzione Account AWS per iscriverti a un argomento di Amazon Simple Notification Service (Amazon SNS) in un altro argomento. Account AWS Quando pubblichi messaggi sul tuo argomento Amazon SNS, la funzione Lambda legge il contenuto del messaggio e lo invia ad Amazon Logs. CloudWatch Per completare questo tutorial, usa il (). AWS Command Line Interface AWS CLI
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-sns-tutorial/sns_tut_resources.png)
Per completare questo tutorial, esegui i passaggi riportati:
+ Nell'**account A**, crea un argomento Amazon SNS.
+ Nell'**account B**, crea una funzione Lambda che leggerà i messaggi dall'argomento.
+ Nell'**account B**, crea una sottoscrizione all'argomento.
+ Pubblica messaggi sull'argomento Amazon SNS nell'**account A** e conferma che la funzione Lambda nell'**account B** li invii nei log. CloudWatch
Completando questi passaggi, imparerai come configurare un argomento Amazon SNS per richiamare una funzione Lambda. Imparerai anche come creare una policy AWS Identity and Access Management (IAM) che autorizzi una risorsa in un'altra Account AWS a richiamare Lambda.
Nel tutorial, vengono utilizzati due Account AWS separati. I AWS CLI comandi illustrano ciò utilizzando due profili denominati chiamati `accountA` e`accountB`, ciascuno configurato per l'uso con un altro. Account AWS Per informazioni su come configurare l'utilizzo AWS CLI di profili diversi, consulta [Impostazioni dei file di configurazione e credenziali](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) nella *Guida per l'AWS Command Line Interface utente della versione 2*. Assicurati di configurare lo stesso valore predefinito Regione AWS per entrambi i profili.
Se i AWS CLI profili creati per i due Account AWS utilizzano nomi diversi o se utilizzi il profilo predefinito e un profilo denominato, modifica i AWS CLI comandi nei passaggi seguenti in base alle esigenze.
## Prerequisiti
### Installa il AWS Command Line Interface
Se non l'hai ancora installato AWS Command Line Interface, segui i passaggi indicati in [Installazione o aggiornamento della versione più recente di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) per installarlo.
Per eseguire i comandi nel tutorial, sono necessari un terminale a riga di comando o una shell (interprete di comandi). In Linux e macOS, utilizza la shell (interprete di comandi) e il gestore pacchetti preferiti.
**Nota**
Su Windows, alcuni comandi della CLI Bash utilizzati comunemente con Lambda (ad esempio, `zip`) non sono supportati dai terminali integrati del sistema operativo. Per ottenere una versione integrata su Windows di Ubuntu e Bash, [installa il sottosistema Windows per Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10).
## Creare un argomento Amazon SNS (account A)
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_1.png)
**Per creare l'argomento**
+ Nell'**account A**, crea un argomento standard di Amazon SNS utilizzando il seguente AWS CLI comando.
```
aws sns create-topic --name sns-topic-for-lambda --profile accountA
```
Verrà visualizzato un output simile al seguente.
```
{
"TopicArn": "arn:aws:sns:us-west-2:123456789012:sns-topic-for-lambda"
}
```
Prendi nota del nome della risorsa Amazon (ARN) dell'argomento. Sarà necessario in seguito nel tutorial, quando aggiungerai autorizzazioni alla funzione Lambda per effettuare la sottoscrizione all'argomento.
## Creazione di un ruolo di esecuzione della funzione (account B)
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_2.png)
Un ruolo di esecuzione è un ruolo IAM che concede a una funzione Lambda l'autorizzazione all' Servizi AWS accesso e alle risorse. Prima di creare la funzione nell'**account B**, crei un ruolo che fornisce alla funzione le autorizzazioni di base per scrivere i log nei registri. CloudWatch Aggiungeremo le autorizzazioni per la lettura dal tuo argomento Amazon SNS in un passaggio successivo.
**Creazione di un ruolo di esecuzione**
1. Nell'**account B** apri la [pagina dei ruoli](https://console.aws.amazon.com/iam/home#/roles) nella console IAM.
1. Scegli **Crea ruolo**.
1. Per **Tipo di entità attendibile**, scegli **Servizio AWS **.
1. In **Caso d'uso**, scegli **Lambda**.
1. Scegli **Next (Successivo)**.
1. Aggiungi una policy di autorizzazioni di base al ruolo completando le seguenti operazioni:
1. Nella casella di ricerca **Policy di autorizzazione**, inserisci **AWSLambdaBasicExecutionRole**.
1. Scegli **Next (Successivo)**.
1. Completa la creazione del ruolo effettuando le seguenti operazioni:
1. In **Dettagli ruolo**, immetti **lambda-sns-role** per **Nome ruolo**.
1. Scegli **Crea ruolo**.
## Creare una funzione Lambda (account B)
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_3.png)
Crea una funzione Lambda che elabora i messaggi Amazon SNS. Il codice funzione registra il contenuto dei messaggi di ogni record in Amazon CloudWatch Logs.
Questo tutorial utilizza il runtime Node.js 24, ma abbiamo anche fornito codice di esempio in altri linguaggi di runtime. Per visualizzare il codice per il runtime che ti interessa, seleziona la scheda corrispondente nella casella seguente. Il JavaScript codice che utilizzerai in questo passaggio si trova nel primo esempio mostrato nella **JavaScript**scheda.
------
#### [ .NET ]
**SDK per .NET**
C'è altro su GitHub. Trova l'esempio completo e scopri come eseguire la configurazione e l'esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Utilizzo di un evento SNS con Lambda tramite .NET.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
using Amazon.Lambda.Core;
using Amazon.Lambda.SNSEvents;
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace SnsIntegration;
public class Function
{
public async Task FunctionHandler(SNSEvent evnt, ILambdaContext context)
{
foreach (var record in evnt.Records)
{
await ProcessRecordAsync(record, context);
}
context.Logger.LogInformation("done");
}
private async Task ProcessRecordAsync(SNSEvent.SNSRecord record, ILambdaContext context)
{
try
{
context.Logger.LogInformation($"Processed record {record.Sns.Message}");
// TODO: Do interesting work based on the new message
await Task.CompletedTask;
}
catch (Exception e)
{
//You can use Dead Letter Queue to handle failures. By configuring a Lambda DLQ.
context.Logger.LogError($"An error occurred");
throw;
}
}
}
```
------
#### [ Go ]
**SDK per Go V2**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Utilizzo di un evento SNS con Lambda tramite Go.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package main
import (
"context"
"fmt"
"github.com/aws/aws-lambda-go/events"
"github.com/aws/aws-lambda-go/lambda"
)
func handler(ctx context.Context, snsEvent events.SNSEvent) {
for _, record := range snsEvent.Records {
processMessage(record)
}
fmt.Println("done")
}
func processMessage(record events.SNSEventRecord) {
message := record.SNS.Message
fmt.Printf("Processed message: %s\n", message)
// TODO: Process your record here
}
func main() {
lambda.Start(handler)
}
```
------
#### [ Java ]
**SDK per Java 2.x**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Utilizzo di un evento SNS con Lambda tramite Java.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package example;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.SNSEvent;
import com.amazonaws.services.lambda.runtime.events.SNSEvent.SNSRecord;
import java.util.Iterator;
import java.util.List;
public class SNSEventHandler implements RequestHandler {
LambdaLogger logger;
@Override
public Boolean handleRequest(SNSEvent event, Context context) {
logger = context.getLogger();
List records = event.getRecords();
if (!records.isEmpty()) {
Iterator recordsIter = records.iterator();
while (recordsIter.hasNext()) {
processRecord(recordsIter.next());
}
}
return Boolean.TRUE;
}
public void processRecord(SNSRecord record) {
try {
String message = record.getSNS().getMessage();
logger.log("message: " + message);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
```
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
C'è altro da fare. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/blob/main/integration-sns-to-lambda).
Consumo di un evento SNS con JavaScript Lambda utilizzando.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
exports.handler = async (event, context) => {
for (const record of event.Records) {
await processMessageAsync(record);
}
console.info("done");
};
async function processMessageAsync(record) {
try {
const message = JSON.stringify(record.Sns.Message);
console.log(`Processed message ${message}`);
await Promise.resolve(1); //Placeholder for actual async work
} catch (err) {
console.error("An error occurred");
throw err;
}
}
```
Consumo di un evento SNS con TypeScript Lambda utilizzando.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { SNSEvent, Context, SNSHandler, SNSEventRecord } from "aws-lambda";
export const functionHandler: SNSHandler = async (
event: SNSEvent,
context: Context
): Promise => {
for (const record of event.Records) {
await processMessageAsync(record);
}
console.info("done");
};
async function processMessageAsync(record: SNSEventRecord): Promise {
try {
const message: string = JSON.stringify(record.Sns.Message);
console.log(`Processed message ${message}`);
await Promise.resolve(1); //Placeholder for actual async work
} catch (err) {
console.error("An error occurred");
throw err;
}
}
```
------
#### [ PHP ]
**SDK per PHP**
C'è altro da fare. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Utilizzo di un evento SNS con Lambda tramite PHP.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
getRecords() as $record) {
$message = $record->getMessage();
// TODO: Implement your custom processing logic here
// Any exception thrown will be logged and the invocation will be marked as failed
echo "Processed Message: $message" . PHP_EOL;
}
}
}
return new Handler();
```
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Utilizzo di un evento SNS con Lambda tramite Python.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
def lambda_handler(event, context):
for record in event['Records']:
process_message(record)
print("done")
def process_message(record):
try:
message = record['Sns']['Message']
print(f"Processed message {message}")
# TODO; Process your record here
except Exception as e:
print("An error occurred")
raise e
```
------
#### [ Ruby ]
**SDK per Ruby**
C'è dell'altro GitHub. Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Utilizzo di un evento SNS con Lambda tramite Ruby.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
def lambda_handler(event:, context:)
event['Records'].map { |record| process_message(record) }
end
def process_message(record)
message = record['Sns']['Message']
puts("Processing message: #{message}")
rescue StandardError => e
puts("Error processing message: #{e}")
raise
end
```
------
#### [ Rust ]
**SDK per Rust**
C'è altro da fare. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Utilizzo di un evento SNS con Lambda tramite Rust.
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
use aws_lambda_events::event::sns::SnsEvent;
use aws_lambda_events::sns::SnsRecord;
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
use tracing::info;
// Built with the following dependencies:
// aws_lambda_events = { version = "0.10.0", default-features = false, features = ["sns"] }
// lambda_runtime = "0.8.1"
// tokio = { version = "1", features = ["macros"] }
// tracing = { version = "0.1", features = ["log"] }
// tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }
async fn function_handler(event: LambdaEvent) -> Result<(), Error> {
for event in event.payload.records {
process_record(&event)?;
}
Ok(())
}
fn process_record(record: &SnsRecord) -> Result<(), Error> {
info!("Processing SNS Message: {}", record.sns.message);
// Implement your record handling code here.
Ok(())
}
#[tokio::main]
async fn main() -> Result<(), Error> {
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
.with_target(false)
.without_time()
.init();
run(service_fn(function_handler)).await
}
```
------
**Creazione della funzione**
1. Crea una directory per il progetto, quindi passa a quella directory.
```
mkdir sns-tutorial
cd sns-tutorial
```
1. Copia il JavaScript codice di esempio in un nuovo file denominato`index.js`.
1. Crea un pacchetto di implementazione utilizzando il seguente comando `zip`.
```
zip function.zip index.js
```
1. Esegui il AWS CLI comando seguente per creare la tua funzione Lambda nell'**account B.**
```
aws lambda create-function --function-name Function-With-SNS \
--zip-file fileb://function.zip --handler index.handler --runtime nodejs24.x \
--role arn:aws:iam:::role/lambda-sns-role \
--timeout 60 --profile accountB
```
Verrà visualizzato un output simile al seguente.
```
{
"FunctionName": "Function-With-SNS",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:Function-With-SNS",
"Runtime": "nodejs24.x",
"Role": "arn:aws:iam::123456789012:role/lambda_basic_role",
"Handler": "index.handler",
...
"RuntimeVersionConfig": {
"RuntimeVersionArn": "arn:aws:lambda:us-west-2::runtime:7d5f06b69c951da8a48b926ce280a9daf2e8bb1a74fc4a2672580c787d608206"
}
}
```
1. Registra il nome della risorsa Amazon (ARN) della funzione. Sarà necessario in seguito nel tutorial, quando aggiungerai autorizzazioni per consentire ad Amazon SNS di richiamare la funzione.
## Aggiunta di autorizzazioni alla funzione (account B)
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_4.png)
Perché Amazon SNS richiami la tua funzione, è necessario concedergli l'autorizzazione in una istruzione su una [policy basata sulle risorse](access-control-resource-based.md). Si aggiunge questa dichiarazione utilizzando il AWS CLI `add-permission` comando.
**Concessione dell'autorizzazione di Amazon SNS per richiamare la tua funzione**
+ Nell'**account B**, esegui il AWS CLI comando seguente utilizzando l'ARN per l'argomento Amazon SNS che hai registrato in precedenza.
```
aws lambda add-permission --function-name Function-With-SNS \
--source-arn arn:aws:sns:us-east-1::sns-topic-for-lambda \
--statement-id function-with-sns --action "lambda:InvokeFunction" \
--principal sns.amazonaws.com --profile accountB
```
Verrà visualizzato un output simile al seguente.
```
{
"Statement": "{\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":
\"arn:aws:sns:us-east-1::sns-topic-for-lambda\"}},
\"Action\":[\"lambda:InvokeFunction\"],
\"Resource\":\"arn:aws:lambda:us-east-1::function:Function-With-SNS\",
\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"sns.amazonaws.com\"},
\"Sid\":\"function-with-sns\"}"
}
```
**Nota**
Se l'account con l'argomento Amazon SNS è ospitato in un [opt-in Regione AWS](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-regions.html), devi specificare la regione nell'area principale. Ad esempio, se stai lavorando con un argomento Amazon SNS nella regione Asia Pacifico (Hong Kong), per il principale devi specificare `sns.ap-east-1.amazonaws.com` invece di `sns.amazonaws.com`.
## Concessione dell'autorizzazione tra più account per la sottoscrizione ad Amazon SNS (account A)
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_5.png)
Perché la funzione Lambda nell'**account B** sottoscriva l'argomento Amazon SNS che hai creato nell'**account A**, è necessario concedere l'autorizzazione per l'**account B** in modo da sottoscrivere il tuo argomento. Concedi questa autorizzazione utilizzando il AWS CLI `add-permission` comando.
**Concessione dell'autorizzazione per consentire all'account B la sottoscrizione all'argomento**
+ Nell'**account A**, esegui il seguente AWS CLI comando. Usa l'ARN per l'argomento Amazon SNS registrato in precedenza.
```
aws sns add-permission --label lambda-access --aws-account-id \
--topic-arn arn:aws:sns:us-east-1::sns-topic-for-lambda \
--action-name Subscribe ListSubscriptionsByTopic --profile accountA
```
## Creare una sottoscrizione (account B)
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_6.png)
Nell'**account B**, ora sottoscrivi la tua funzione Lambda all'argomento Amazon SNS che hai creato all'inizio del tutorial nell'**account A**. Quando viene inviato un messaggio a questo argomento (`sns-topic-for-lambda`), Amazon SNS richiama la funzione Lambda `Function-With-SNS` nell'**account B**.
**Creazione di una sottoscrizione**
+ Nell'**account B**, esegui il AWS CLI comando seguente. Usa l'area predefinita in cui hai creato l'argomento e la funzione ARNs for your topic e Lambda.
```
aws sns subscribe --protocol lambda \
--region us-east-1 \
--topic-arn arn:aws:sns:us-east-1::sns-topic-for-lambda \
--notification-endpoint arn:aws:lambda:us-east-1::function:Function-With-SNS \
--profile accountB
```
Verrà visualizzato un output simile al seguente.
```
{
"SubscriptionArn": "arn:aws:sns:us-east-1::sns-topic-for-lambda:5d906xxxx-7c8x-45dx-a9dx-0484e31c98xx"
}
```
## Pubblicazione di messaggi sull'argomento (account A e account B)
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_7.png)
Ora che la tua funzione Lambda nell'**account B** ha sottoscritto l'argomento Amazon SNS nell'**account A**, è il momento di testare la configurazione pubblicando messaggi sull'argomento. Per confermare che Amazon SNS ha richiamato la funzione Lambda, utilizza CloudWatch Logs per visualizzare l'output della funzione.
**Pubblicazione di un messaggio sull' argomento e visualizzazione dell'output della tua funzione**
1. Digita `Hello World` in un file di testo e salvalo come `message.txt`.
1. **Dalla stessa directory in cui hai salvato il file di testo, esegui il seguente AWS CLI comando nell'account A.** Usa l'ARN per il tuo argomento.
```
aws sns publish --message file://message.txt --subject Test \
--topic-arn arn:aws:sns:us-east-1::sns-topic-for-lambda \
--profile accountA
```
In questo modo verrà restituito un ID messaggio con un identificatore univoco, indicando che il messaggio è stato accettato da Amazon SNS. Amazon SNS prova quindi a consegnare il messaggio a tutti i sottoscrittori dell'argomento. Per confermare che Amazon SNS ha richiamato la funzione Lambda, usa CloudWatch Logs per visualizzare l'output della funzione:
1. Nell'**account B**, apri la pagina dei [gruppi di log](https://console.aws.amazon.com/cloudwatch/home#logsV2:log-groups) della CloudWatch console Amazon.
1. Scegli il nome del gruppo di log per la funzione (`/aws/lambda/Function-With-SNS`).
1. Scegli il flusso di log più recente.
1. Se la funzione è stata richiamata correttamente, vedrai un output simile al seguente che mostra il contenuto del messaggio pubblicato sull'argomento.
```
2023-07-31T21:42:51.250Z c1cba6b8-ade9-4380-aa32-d1a225da0e48 INFO Processed message Hello World
2023-07-31T21:42:51.250Z c1cba6b8-ade9-4380-aa32-d1a225da0e48 INFO done
```
## Pulizia delle risorse
Ora è possibile eliminare le risorse create per questo tutorial, a meno che non si voglia conservarle. Eliminando AWS le risorse che non utilizzi più, eviti addebiti inutili ai tuoi Account AWS.
Nell'**Account A**, elimina l'argomento Amazon SNS.
**Per eliminare l'argomento Amazon SNS**
1. Aprire la [pagina Topics (Argomenti)](https://console.aws.amazon.com//sns/home#topics:) nella console Amazon SNS.
1. Selezionare l'argomento creato.
1. Scegli **Elimina**.
1. Inserisci **delete me** nel campo di immissione del testo.
1. Scegli **Elimina**.
Nell'**Account B**, elimina il ruolo di esecuzione, la funzione Lambda e la sottoscrizione Amazon SNS.
**Come eliminare il ruolo di esecuzione**
1. Aprire la pagina [Ruoli](https://console.aws.amazon.com/iam/home#/roles) della console IAM.
1. Selezionare il ruolo di esecuzione creato.
1. Scegliere **Elimina**.
1. Inserisci il nome del ruolo nel campo di immissione testo e seleziona **Delete** (Elimina).
**Per eliminare la funzione Lambda**
1. Aprire la pagina [Functions (Funzioni)](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Selezionare la funzione creata.
1. Scegliere **Operazioni**, **Elimina**.
1. Digita **confirm** nel campo di immissione testo e scegli **Delete** (Elimina).
**Per eliminare la sottoscrizione Amazon SNS**
1. Aprire la [pagina Subscriptions (Sottoscrizioni)](https://console.aws.amazon.com//sns/home#subscriptions:) nella console Amazon SNS.
1. Selezionare la sottoscrizione creata.
1. Scegli **Delete** (Elimina), poi **Delete** (Elimina).