Tutoriel : Utilisation AWS Lambda avec Amazon Simple Notification Service

Prérequis Créer un SNS sujet Amazon (compte A)Créer un rôle d'exécution de fonction (compte B)Créer une fonction Lambda (compte B)Ajouter des autorisations à la fonction (compte B)Accorder une autorisation multi-comptes pour l'SNSabonnement Amazon (compte A)Créer un abonnement (compte B)Publier des messages sur la rubrique (compte A et compte B)Nettoyage de vos ressources

Dans ce didacticiel, vous utiliserez une fonction Lambda pour vous abonner Compte AWS à une rubrique Amazon Simple Notification Service SNS (Amazon) dans une rubrique séparée. Compte AWS Lorsque vous publiez des messages sur votre SNS sujet Amazon, votre fonction Lambda lit le contenu du message et le transmet à Amazon CloudWatch Logs. Pour terminer ce didacticiel, vous devez utiliser le AWS Command Line Interface (AWS CLI).

Une SNS rubrique Amazon connectée à une fonction Lambda connectée à un groupe de CloudWatch journaux Logs

Pour compléter ce tutoriel, effectuez les tâches suivantes :

Dans le compte A, créez un SNS sujet Amazon.
Dans le compte B, créez une fonction Lambda qui lira les messages de la rubrique.
Dans le compte B, créez un abonnement à la rubrique.
Publiez des messages sur le SNS sujet Amazon dans le compte A et vérifiez que la fonction Lambda du compte B les envoie dans Logs. CloudWatch

En suivant ces étapes, vous apprendrez à configurer une SNS rubrique Amazon pour appeler une fonction Lambda. Vous apprendrez également comment créer une politique AWS Identity and Access Management (IAM) qui autorise une ressource d'une autre Compte AWS à invoquer Lambda.

Dans le tutoriel, vous utilisez deux Comptes AWS différents. Les AWS CLI commandes illustrent cela en utilisant deux profils nommés appelés accountA etaccountB, chacun étant configuré pour être utilisé avec un profil différent Compte AWS. Pour savoir comment configurer le AWS CLI pour utiliser différents profils, consultez la section Paramètres des fichiers de configuration et d'identification dans le guide de l'AWS Command Line Interface utilisateur de la version 2. Assurez-vous de configurer la même valeur par défaut Région AWS pour les deux profils.

Si les AWS CLI profils que vous créez pour les deux Comptes AWS utilisent des noms différents, ou si vous utilisez le profil par défaut et un profil nommé, modifiez les AWS CLI commandes dans les étapes suivantes selon vos besoins.

Si vous n'en avez pas Compte AWS, procédez comme suit pour en créer un.

Pour vous inscrire à un Compte AWS

Ouvrez l'https://portal.aws.amazon.com/billing/inscription.
Suivez les instructions en ligne.

Dans le cadre de la procédure d‘inscription, vous recevrez un appel téléphonique et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.

Lorsque vous vous inscrivez à un Compte AWS, un Utilisateur racine d'un compte AWSest créé. Par défaut, seul l‘utilisateur racine a accès à l‘ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur, et à utiliser uniquement l‘utilisateur racine pour effectuer les tâches nécessitant un accès utilisateur racine.

AWS vous envoie un e-mail de confirmation une fois le processus d'inscription terminé. À tout moment, vous pouvez consulter l'activité actuelle de votre compte et gérer votre compte en accédant à https://aws.amazon.com/et en choisissant Mon compte.

Une fois que vous vous êtes inscrit à un utilisateur administratif Compte AWS, que vous Utilisateur racine d'un compte AWS l'avez sécurisé AWS IAM Identity Center, que vous l'avez activé et que vous en avez créé un, afin de ne pas utiliser l'utilisateur root pour les tâches quotidiennes.

Sécurisez votre Utilisateur racine d'un compte AWS

Connectez-vous en AWS Management Consoletant que propriétaire du compte en choisissant Utilisateur root et en saisissant votre adresse Compte AWS e-mail. Sur la page suivante, saisissez votre mot de passe.

Pour obtenir de l‘aide pour vous connecter en utilisant l‘utilisateur racine, consultez Connexion en tant qu‘utilisateur racine dans le Guide de l‘utilisateur Connexion à AWS .
Activez l'authentification multifactorielle (MFA) pour votre utilisateur root.

Pour obtenir des instructions, voir Activer un MFA périphérique virtuel pour votre utilisateur Compte AWS root (console) dans le guide de IAM l'utilisateur.

Création d'un utilisateur doté d'un accès administratif

Activez IAM Identity Center.

Pour obtenir des instructions, consultez Activation d’ AWS IAM Identity Center dans le Guide de l’utilisateur AWS IAM Identity Center .
Dans IAM Identity Center, accordez un accès administratif à un utilisateur.

Pour un didacticiel sur l'utilisation du Répertoire IAM Identity Center comme source d'identité, voir Configurer l'accès utilisateur par défaut Répertoire IAM Identity Center dans le Guide de AWS IAM Identity Center l'utilisateur.

Connexion en tant qu‘utilisateur doté d'un accès administratif

Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l'URLidentifiant envoyé à votre adresse e-mail lorsque vous avez créé l'utilisateur IAM Identity Center.

Pour obtenir de l'aide pour vous connecter en utilisant un utilisateur d'IAMIdentity Center, consultez la section Connexion au portail AWS d'accès dans le guide de Connexion à AWS l'utilisateur.

Attribution d'un accès à d'autres utilisateurs

Dans IAM Identity Center, créez un ensemble d'autorisations conforme à la meilleure pratique consistant à appliquer les autorisations du moindre privilège.

Pour obtenir des instructions, consultez Création d’un ensemble d’autorisations dans le Guide de l’utilisateur AWS IAM Identity Center .
Attribuez des utilisateurs à un groupe, puis attribuez un accès par authentification unique au groupe.

Pour obtenir des instructions, consultez Ajout de groupes dans le Guide de l’utilisateur AWS IAM Identity Center .

Si vous ne l'avez pas encore installé AWS Command Line Interface, suivez les étapes décrites dans la section Installation ou mise à jour de la dernière version du AWS CLI pour l'installer.

Ce tutoriel nécessite un terminal de ligne de commande ou un shell pour exécuter les commandes. Sous Linux et macOS, utilisez votre gestionnaire de shell et de package préféré.

Note

Sous Windows, certaines CLI commandes Bash que vous utilisez couramment avec Lambda (ziptelles que) ne sont pas prises en charge par les terminaux intégrés du système d'exploitation. Installez le sous-système Windows pour Linux afin d’obtenir une version intégrée à Windows d’Ubuntu et Bash.

Première étape : créer le SNS sujet Amazon

Pour créer la rubrique

Dans le compte A, créez un sujet SNS standard Amazon à l'aide de la AWS CLI commande suivante.
```
aws sns create-topic --name sns-topic-for-lambda --profile accountA
```
Vous devez visualiser des résultats similaires à ce qui suit.
```
{
    "TopicArn": "arn:aws:sns:us-west-2:123456789012:sns-topic-for-lambda"
}
```
Notez le nom de ressource Amazon (ARN) de votre sujet. Vous en aurez besoin plus tard dans le tutoriel lorsque vous ajouterez des autorisations à votre fonction Lambda pour vous abonner à cette rubrique.

Étape suivante : créer le rôle d'exécution

Un rôle d'exécution est un IAM rôle qui accorde à une fonction Lambda l'autorisation d'accéder aux AWS services et aux ressources. Avant de créer votre fonction dans le compte B, vous devez créer un rôle qui donne à la fonction les autorisations de base pour écrire des journaux dans CloudWatch Logs. Nous ajouterons les autorisations nécessaires pour lire un extrait de votre SNS rubrique Amazon ultérieurement.

Pour créer un rôle d’exécution

Dans le compte B, ouvrez la page des rôles dans la IAM console.
Sélectionnez Créer un rôle.
Pour Type d’entité de confiance, choisissez Service AWS .
Pour Cas d’utilisation, choisissez Lambda.
Choisissez Suivant.
Ajoutez une stratégie d'autorisations de base au rôle en procédant comme suit :
1. Dans le champ de recherche Politiques d’autorisations, saisissez AWSLambdaBasicExecutionRole.
2. Choisissez Suivant.
Finalisez la création du rôle en procédant comme suit :
1. Sous Détails du rôle, saisissez lambda-sns-role pour Nom du rôle.
2. Sélectionnez Créer un rôle.

Créez une fonction Lambda qui traite vos messages AmazonSNS. Le code de fonction enregistre le contenu des messages de chaque enregistrement dans Amazon CloudWatch Logs.

Ce didacticiel utilise l’exécution Node.js 18.x, mais nous avons également fourni des exemples de code dans d’autres langages d’exécution. Vous pouvez sélectionner l’onglet dans la zone suivante pour voir le code de l’exécution qui vous intéresse. Le JavaScript code que vous allez utiliser dans cette étape se trouve dans le premier exemple présenté dans l'JavaScriptonglet.

.NET

AWS SDK for .NET

Note

Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Consommation d'un SNS événement avec Lambda en utilisant. 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

SDKpour Go V2

Note

Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Consommation d'un SNS événement avec Lambda à l'aide de 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

SDKpour Java 2.x

Note

Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Utilisation d'un SNS événement avec Lambda à l'aide de 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<SNSEvent, Boolean> {
    LambdaLogger logger;

    @Override
    public Boolean handleRequest(SNSEvent event, Context context) {
        logger = context.getLogger();
        List<SNSRecord> records = event.getRecords();
        if (!records.isEmpty()) {
            Iterator<SNSRecord> 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

SDKpour JavaScript (v3)

Note

Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Consommation d'un SNS événement avec Lambda en utilisant. JavaScript


// 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;
  }
}

Consommation d'un SNS événement avec Lambda en utilisant. TypeScript


// 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<void> => {
  for (const record of event.Records) {
    await processMessageAsync(record);
  }
  console.info("done");
};

async function processMessageAsync(record: SNSEventRecord): Promise<any> {
  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 pour PHP

Note

Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Consommation d'un SNS événement avec Lambda en utilisant. PHP


// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
<?php

/* 
Since native PHP support for AWS Lambda is not available, we are utilizing Bref's PHP functions runtime for AWS Lambda.
For more information on Bref's PHP runtime for Lambda, refer to: https://bref.sh/docs/runtimes/function

Another approach would be to create a custom runtime. 
A practical example can be found here: https://aws.amazon.com/blogs/apn/aws-lambda-custom-runtime-for-php-a-practical-example/
*/

// Additional composer packages may be required when using Bref or any other PHP functions runtime.
// require __DIR__ . '/vendor/autoload.php';

use Bref\Context\Context;
use Bref\Event\Sns\SnsEvent;
use Bref\Event\Sns\SnsHandler;

class Handler extends SnsHandler
{
    public function handleSns(SnsEvent $event, Context $context): void
    {
        foreach ($event->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

SDKpour Python (Boto3)

Note

Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Consommer un SNS événement avec Lambda à l'aide de 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

SDKpour Ruby

Note

Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Consommer un SNS événement avec Lambda à l'aide de 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

SDKpour Rust

Note

Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples sans serveur.

Consommer un SNS événement avec Lambda en utilisant 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<SnsEvent>) -> 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
}

Pour créer la fonction

Créez un répertoire pour le projet, puis passez à ce répertoire.
```
mkdir sns-tutorial
cd sns-tutorial
```
Copiez l'exemple de JavaScript code dans un nouveau fichier nomméindex.js.
Créez un package de déploiement à l’aide de la commande zip suivante.
```
zip function.zip index.js
```

Exécutez la AWS CLI commande suivante pour créer votre fonction Lambda dans le compte B.


aws lambda create-function --function-name Function-With-SNS \
    --zip-file fileb://function.zip --handler index.handler --runtime nodejs18.x \
    --role arn:aws:iam::<AccountB_ID>:role/lambda-sns-role  \
    --timeout 60 --profile accountB

Vous devez visualiser des résultats similaires à ce qui suit.


{
    "FunctionName": "Function-With-SNS",
    "FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:Function-With-SNS",
    "Runtime": "nodejs18.x",
    "Role": "arn:aws:iam::123456789012:role/lambda_basic_role",
    "Handler": "index.handler",
    ...
    "RuntimeVersionConfig": {
        "RuntimeVersionArn": "arn:aws:lambda:us-west-2::runtime:7d5f06b69c951da8a48b926ce280a9daf2e8bb1a74fc4a2672580c787d608206"
    }
}

Enregistrez le nom de ressource Amazon (ARN) de votre fonction. Vous en aurez besoin plus tard dans le didacticiel lorsque vous ajouterez des autorisations permettant SNS à Amazon d'appeler votre fonction.

Étape suivante : ajouter des autorisations pour fonctionner

Pour SNS qu'Amazon puisse invoquer votre fonction, vous devez lui accorder une autorisation dans une déclaration relative à une politique basée sur les ressources. Vous ajoutez cette instruction à l'aide de la AWS CLI add-permission commande.

Pour SNS autoriser Amazon à appeler votre fonction

Dans le compte B, exécutez la AWS CLI commande suivante à l'aide ARN de la SNS rubrique Amazon que vous avez enregistrée précédemment.


aws lambda add-permission --function-name Function-With-SNS \
    --source-arn arn:aws:sns:us-east-1:<AccountA_ID>:sns-topic-for-lambda \
    --statement-id function-with-sns --action "lambda:InvokeFunction" \
    --principal sns.amazonaws.com --profile accountB

Vous devez visualiser des résultats similaires à ce qui suit.


{
    "Statement": "{\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":
      \"arn:aws:sns:us-east-1:<AccountA_ID>:sns-topic-for-lambda\"}},
      \"Action\":[\"lambda:InvokeFunction\"],
      \"Resource\":\"arn:aws:lambda:us-east-1:<AccountB_ID>:function:Function-With-SNS\",
      \"Effect\":\"Allow\",\"Principal\":{\"Service\":\"sns.amazonaws.com\"},
      \"Sid\":\"function-with-sns\"}"
}

Note

Si le compte associé au SNS sujet Amazon est hébergé dans le cadre d'un opt-in Région AWS, vous devez spécifier la région dans le principal. Par exemple, si vous travaillez sur un SNS sujet Amazon dans la région Asie-Pacifique (Hong Kong), vous devez le spécifier sns.ap-east-1.amazonaws.com plutôt que sns.amazonaws.com pour le principal.

Étape suivante : accorder une autorisation entre comptes

Pour que votre fonction Lambda du compte B puisse s'abonner au SNS sujet Amazon que vous avez créé dans le compte A, vous devez autoriser le compte B à s'abonner à votre sujet. Vous accordez cette autorisation à l'aide de la AWS CLI add-permission commande.

Pour accorder l'autorisation permettant au compte B de s'abonner à la rubrique

Dans le compte A, exécutez la AWS CLI commande suivante. Utilisez le ARN pour le SNS sujet Amazon que vous avez enregistré précédemment.


aws sns add-permission --label lambda-access --aws-account-id <AccountB_ID> \
    --topic-arn arn:aws:sns:us-east-1:<AccountA_ID>:sns-topic-for-lambda \  
    --action-name Subscribe ListSubscriptionsByTopic --profile accountA

Dans le compte B, vous abonnez désormais votre fonction Lambda à la SNS rubrique Amazon que vous avez créée au début du didacticiel dans le compte A. Lorsqu'un message est envoyé à cette rubrique (sns-topic-for-lambda), Amazon SNS invoque votre Function-With-SNS fonction Lambda dans le compte B.

Pour créer un abonnement

Dans le compte B, exécutez la AWS CLI commande suivante. Utilisez la région par défaut dans laquelle vous avez créé votre sujet, ainsi que la région ARNs correspondant à votre sujet et la fonction Lambda.


aws sns subscribe --protocol lambda \
    --region us-east-1 \
    --topic-arn arn:aws:sns:us-east-1:<AccountA_ID>:sns-topic-for-lambda \
    --notification-endpoint arn:aws:lambda:us-east-1:<AccountB_ID>:function:Function-With-SNS \
    --profile accountB

Vous devez visualiser des résultats similaires à ce qui suit.


{
    "SubscriptionArn": "arn:aws:sns:us-east-1:<AccountA_ID>:sns-topic-for-lambda:5d906xxxx-7c8x-45dx-a9dx-0484e31c98xx"
}

Maintenant que votre fonction Lambda du compte B est abonnée à votre SNS rubrique Amazon dans le compte A, il est temps de tester votre configuration en publiant des messages sur votre sujet. Pour confirmer qu'Amazon SNS a invoqué votre fonction Lambda, utilisez CloudWatch Logs pour afficher le résultat de votre fonction.

Pour publier un message sur votre rubrique et consulter le résultat de votre fonction

Saisissez Hello World dans un fichier texte et enregistrez-le sous message.txt.
À partir du répertoire dans lequel vous avez enregistré votre fichier texte, exécutez la AWS CLI commande suivante dans le compte A. Utilisez-le ARN pour votre propre sujet.
```
aws sns publish --message file://message.txt --subject Test \
    --topic-arn arn:aws:sns:us-east-1:<AccountA_ID>:sns-topic-for-lambda \
    --profile accountA
```
Cela renverra un identifiant de message avec un identifiant unique, indiquant qu'Amazon SNS a accepté le message. Amazon tente SNS ensuite de transmettre le message aux abonnés du sujet. Pour vérifier qu'Amazon SNS a invoqué votre fonction Lambda, utilisez CloudWatch Logs pour afficher le résultat de votre fonction :
Dans le compte B, ouvrez la page Log groups de la CloudWatch console Amazon.
Choisissez le groupe de journaux de votre fonction (/aws/lambda/Function-With-SNS).
Choisissez le flux de journaux le plus récent.
Si votre fonction a été correctement invoquée, vous verrez une sortie similaire à la suivante montrant le contenu du message que vous avez publié dans votre rubrique.
```
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
```

Nettoyage de vos ressources

Vous pouvez maintenant supprimer les ressources que vous avez créées pour ce didacticiel, sauf si vous souhaitez les conserver. En supprimant AWS les ressources que vous n'utilisez plus, vous évitez des frais inutiles pour votre Compte AWS.

Dans le compte A, nettoyez votre SNS rubrique Amazon.

Pour supprimer le SNS sujet Amazon

Ouvrez la page Rubriques de la SNS console Amazon.
Sélectionnez la rubrique que vous avez créée.
Sélectionnez Delete (Supprimer).
Saisissez delete me dans le champ de saisie de texte.
Sélectionnez Delete (Supprimer).

Dans le compte B, nettoyez votre rôle d'exécution, votre fonction Lambda et votre abonnement AmazonSNS.

Pour supprimer le rôle d’exécution

Ouvrez la page Rôles de la IAM console.
Sélectionnez le rôle d’exécution que vous avez créé.
Sélectionnez Delete (Supprimer).
Saisissez le nom du rôle dans le champ de saisie de texte et choisissez Delete (Supprimer).

Pour supprimer la fonction Lambda

Ouvrez la page Functions (Fonctions) de la console Lambda.
Sélectionnez la fonction que vous avez créée.
Sélectionnez Actions, Supprimer.
Saisissez delete dans la zone de saisie de texte et choisissez Delete (Supprimer).

Pour supprimer l'SNSabonnement Amazon

Ouvrez la page Abonnements de la SNS console Amazon.
Sélectionnez l'abonnement que vous avez créé.
Choisissez Delete (Supprimer), Delete (Supprimer).

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

SNS

Autorisations Lambda